Do I need a GPU to run CrewAI?

No — not for the usual setup. CrewAI orchestrates agents; the actual thinking happens in an LLM you call over an API (OpenAI, Anthropic, etc.). Your server just runs Python, holds the crew logic, and makes HTTP calls. That's CPU and RAM work, not GPU. You'd only want a GPU if you run the model locally too (e.g. via Ollama), which is a different, much heavier setup.

What size VPS do I need?

Most crews are light on the box because the heavy lifting is remote. A 1–2 GB RAM plan handles a small crew comfortably. Bump to 4 GB if you run several crews, keep long conversation histories in memory, or add a vector store for agent memory. Start small — you can resize later.

How do I keep the crew running after I disconnect?

Run it as a systemd service (recommended) or in tmux for quick tests. systemd restarts it if it crashes and starts it on boot — which is the whole point of moving off your laptop. There's a full pattern below.

Can I pay without a card or ID?

Yes. EQVPS takes USDC or USDT on Base, Ethereum or Polygon, and there's no identity check. Signup is an email and a one-time code. Base has the lowest network fees if you're funding a small balance.

Can the agent rent its own server?

Yes — EQVPS exposes an MCP server (mcp.eqvps.com/mcp), so an agent with a funded balance can call order_vps and provision a box itself. Useful if one of your crew's jobs is spinning up infrastructure.

Run a CrewAI multi-agent crew on a VPS

Your CrewAI crew runs great on your laptop. The agents talk to each other, the researcher hands off to the writer, the whole thing hums — right up until you close the lid and it all stops. Or your wifi drops mid-task. Or you reboot and forget to restart it.

A crew that only runs while you're watching isn't automation. It's a demo. Moving it to a VPS is what turns it into something that actually works while you sleep.

Why a server, not your machine

The pitch is simple: a VPS is a computer that never closes its lid. It has a fixed IP, it doesn't sleep, and if the process dies it can bring itself back. For a multi-agent crew — which by design runs long, chatty, multi-step jobs — that's the difference between "it worked once" and "it's been running for three weeks."

There's a second reason that trips people up in a good way: you don't need a powerful machine. More on that next, because it's the question everyone asks first.

No, you don't need a GPU

This is the part people get wrong about hosting agents. CrewAI is an orchestrator. It decides which agent acts, in what order, with what context — and then it asks a language model to do the actual reasoning. That model almost always lives behind an API: you send a request to OpenAI or Anthropic, they run it on their GPUs, you get text back.

So your server does three things: run Python, hold the crew's state, and make HTTPS calls. None of that touches a GPU. A plain CPU VPS is exactly right. The only time that changes is if you also want to run the model locally — but that's a separate, heavier project, and most crews don't.

Practically: a 1–2 GB plan runs a small crew without breaking a sweat. Go to 4 GB if you're running several crews at once, holding big conversation histories in RAM, or bolting on a vector database for long-term agent memory.

The actual setup

Fresh Ubuntu box, root in about a minute after ordering. Here's the whole thing:

# Python + venv
apt update && apt install -y python3-venv python3-pip
python3 -m venv ~/crew && source ~/crew/bin/activate

# CrewAI
pip install crewai crewai-tools

# your project
mkdir ~/mycrew && cd ~/mycrew
# copy your crew.py and .env up here (scp / git clone)

Your .env holds the one secret that matters — the LLM API key:

OPENAI_API_KEY=sk-...
# or ANTHROPIC_API_KEY, etc.

Then a normal python crew.py runs it. That's the manual version. It works, but it dies the moment your SSH session closes — which brings us to the actual point of a server.

Keep it alive with systemd

tmux is fine for a quick test. For anything real, use systemd — it restarts the crew if it crashes and brings it up on reboot. Drop this in /etc/systemd/system/mycrew.service:

[Unit]
Description=CrewAI crew
After=network-online.target

[Service]
WorkingDirectory=/root/mycrew
ExecStart=/root/crew/bin/python /root/mycrew/crew.py
Restart=always
RestartSec=5
EnvironmentFile=/root/mycrew/.env

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now mycrew
journalctl -u mycrew -f   # watch it work

Now the crew runs on boot, restarts on failure, and logs everywhere you can read them. Close your laptop — it doesn't care.

Paying for it

Signup is an email and a one-time code — no card, no ID. You fund a balance with USDC or USDT on Base, Ethereum or Polygon (Base is cheapest on fees), and orders draw from it. For a crew that mostly makes outbound API calls, the default NAT plan is fine and cheaper; pick a -ip plan only if the crew needs its own public IPv4 for inbound services.

One nice trick: EQVPS has an MCP server at mcp.eqvps.com/mcp. If provisioning is itself one of your crew's jobs, an agent with a funded balance can call order_vps and stand up a box on its own — no human at the checkout.

What's honest to say

You bring the LLM API keys. We host the crew, not the model. Your OpenAI/Anthropic bill is separate and, for a busy crew, usually the larger cost — the VPS is the cheap part.

It's CPU-only, one datacenter in Germany. No local GPU inference, and latency is best if your users or APIs are Europe-adjacent. For a crew hitting US-hosted LLM APIs the extra hop is milliseconds — irrelevant next to model latency — but worth knowing.

Size for your memory, not your model. The thing that actually grows your RAM use is conversation history and any vector store you add, not the number of agents. Watch journalctl and htop for a day and resize if you need to.

The takeaway

A CrewAI crew belongs on something that doesn't sleep. The move is short: a CPU VPS, pip install crewai, a systemd unit, your API key in a .env. Ten minutes and your crew is running 24/7 instead of "whenever the laptop's open." Root in about a minute, pay in crypto, resize when the memory tells you to — and let the agents get on with it.