VPS for AI Agents: How Much RAM and CPU You Need, 8 Agents Measured

A VPS for AI agents can be small when the model runs at an API provider: 2 GB of RAM carries a chat agent such as Hermes or an n8n AI workflow, and 4 GB carries OpenClaw, Paperclip or a coding agent. In our October 2026 lab, eight agent runtimes ran one at a time on 2 vCPUs with a 3 GB memory limit, and none used 1 GB while idle. Memory grows when the agent works: OpenClaw reached about 1.6 GiB in one turn, and a headless browser with 10 real web pages open took about 1 GB. The tables below match each case to one of our VPS hosting plans and a city.

Key facts, checked on 17 October 2026:

• Anthropic lists "4 GB+ RAM" for Claude Code (Claude Code docs). Claude Code 2.1.302 itself held 142 MiB idle in our lab.
• OpenClaw's DigitalOcean guide starts on a 1 vCPU, 1 GB Droplet and recommends swap on that size (OpenClaw docs). Our OpenClaw 2026.10.4 gateway used 913 MiB doing nothing.
• Lightpanda 1.0.1's README reports 123 MB of peak memory against 2 GB for headless Chrome over 100 pages (Lightpanda on GitHub). On our 10 real pages its engine used 2.2 to 3 times less memory than Chromium's, not 16 times less.
• Obscura 0.2.5's README lists 30 MB against "200+ MB" for headless Chrome (Obscura on GitHub). We measured 52 MiB with one page and peaks of 819 to 898 MiB with ten.
• Browser Use warns that smaller Qwen models "may return incorrect action schema formats" (Browser Use docs). Our 1.5B Qwen run on CPU invented a tab, then the model server ran out of memory.

API model or local model: what sets the size

An AI agent is a program that gives a language model a task, lets it pick tools such as files, shell commands or a browser, runs them, and repeats until the job is done. If the model runs at an API provider such as Anthropic, OpenAI or OpenRouter, your server only runs the loop and the tools, and a small VPS is enough. A model on your own server wants gigabytes of memory and every core, and our servers have no GPU, so every plan below assumes a cloud model unless the row says otherwise. To manage those provider keys in one place, see our self-hosted AI gateway comparison.

AI agent VPS requirements: RAM, CPU and disk for 8 agents

RAM here is the working set: memory the agent's processes really use, without the file cache Linux can drop at any time, the same figure docker stats shows. 1 MiB is 1.05 MB. "Idle" is the average over one to two minutes of waiting; "working peak" is the highest value during a real task.

Add the operating system on top. A container does not count the Linux kernel, but a real KVM server (a full virtual machine) does: on the 1 GB test VM from our Hermes guide, Debian 13 plus the idle gateway left 414 MB available. Plan for the working peak, a few hundred MB for Debian, and room for whatever the agent runs, such as a test suite or a database.

How we tested

All runs used our Amsterdam lab server (AMD EPYC 7742, 8 cores) in October 2026. Each test ran in a fresh Debian 13 container limited to 2 vCPUs and 3 GB without swap, and a script read the agent's memory and CPU counters from the kernel twice a second. Other labs shared the host, whose load average stayed between 7 and 9, so treat the CPU figures as approximate.

We used no paid API keys. To make each agent take one real step, we pointed it at Ollama 0.40.6, a program that runs open models locally, with Qwen2.5 0.5B or 1.5B, and counted the model separately. Browser tests loaded five light pages (Wikipedia, Hacker News, debian.org, MDN, the Python docs) and five heavy ones (GitHub, BBC News, the Guardian, nodejs.org, w3.org).

Always-on gateways: Hermes, OpenClaw, Paperclip

A gateway is the part of an agent that runs all day, waits for messages from Telegram, Slack or a web page, and passes them to the model. Its idle size is what you pay for around the clock.

Hermes Agent was the lightest: the gateway held 216 MiB and under 1% of one core idle, and a chat turn started from the command line peaked at 194 MiB in its own process. The install is the heavy part, 2.5 GiB on disk, and on 1 GB the installer needs a swap file, as our Hermes Agent setup guide shows.

OpenClaw took 18.4 seconds and 21.5 CPU-seconds to report healthy, ran at 47% of a core for 30 seconds, then settled at 913 MiB and 3.6%. In our test turns it built 16,482-token prompts and logged its own memory warning at 1.6 GiB. With a 1.5B model beside it in 3 GB, the kernel's OOM killer, which ends a process when memory runs out, stopped the gateway. That is why our OpenClaw security setup guide starts at 4 GB, and why the best VPS for OpenClaw in our range is the VPS Mini.

Paperclip, started through npx with its built-in PostgreSQL, idled at 736 MiB and peaked at 778 MiB during a 6.8-second heartbeat run. Its 30-second heartbeat and nine PostgreSQL processes kept about 10% of one core busy all the time. Disk is the other cost: 2.4 GiB of npm cache, or 6.99 GB for the Docker image in our Paperclip self-hosting guide.

Keep gateways apart and private. In our lab the agents ran as non-root Linux users, and the OpenClaw gateway and the Paperclip server listened only on 127.0.0.1, the loopback address the internet cannot reach. On a server that hosts several agents, give each one its own Linux user so one cannot read another's keys or files, and open their web panels through an SSH tunnel or a VPN, not a public port. Our guide to a self-hosted MCP gateway covers controlling which tools each agent can reach.

Coding agents and n8n: small runtimes, big jobs

Claude Code held 142 MiB idle and 268 MiB during a prompt. Codex held 205 MiB at its sign-in screen and peaked at 103 MiB in a codex exec run. Anthropic still asks for 4 GB, with reason: the agent runs your tools, and an npm install, a test suite or a Docker build can take gigabytes and every core. Our guide to running Claude Code and Codex 24/7 starts at a VPS Mini for that reason.

For n8n we built a webhook, an AI Agent node with the Ollama chat model and a Calculator tool. Idle n8n used 396 MiB. One request for 1234 times 5678 came back correct (7,006,652) in 16 seconds with n8n at 600 MiB. Five at once all returned within 41 seconds, mostly wrong, which is the small model's fault. Our n8n requirements load test covers throughput, and the n8n VPS hosting page lists matching plans. Companies weighing an office server against a private VPS can read our n8n on-premise guide.

Browser agent RAM: the pages decide it

A browser agent reads and clicks web pages through a headless browser: a normal browser engine with no window, driven by code. The browser is cheap; each open page is not, and a news site costs far more than a documentation page. Here is Playwright from Python driving Chromium, whole stack included:

The headless shell is the slimmer Chromium build Playwright uses by default for headless runs. Full Chromium cost 45 to 124 MiB more on average at every step and was slower to load all ten pages (6.9 seconds against 4.6 to 5.2). Each extra light page added 40 to 70 MiB, each heavy one about 100 MiB. One page cost about 1 CPU-second, and ten pages held open for 20 seconds cost 10.9 to 16.

Browser Use adds its own work. On every step it turns the page into a numbered list of clickable elements, text and a screenshot for the model: 158 elements and 11,966 characters for the Wikipedia page. One page peaked at 443 MiB with 7.8 CPU-seconds, five tabs at 668 MiB. A single browser agent fits a 2 GB server; a fleet of them is a different budget.

Chromium, Lightpanda or Obscura for browser agents?

Lightpanda (Zig, AGPL licence) and Obscura (Rust, Apache licence) are headless browsers built for agents and scrapers. Both run JavaScript in V8, Chrome's engine, and speak the Chrome DevTools Protocol (CDP), the remote-control interface Playwright uses, so Playwright can drive them. Here we measured each engine alone; the Playwright client adds 107 to 144 MiB.

Lightpanda is the real saver: ten pages in about 300 MiB, loaded in 2.6 to 3.7 seconds with the least CPU. A second page in one browser context failed with TargetAlreadyLoaded, so each page needs its own CDP connection (16 by default). Iframes stay off unless you enable them, and page text can differ from Chromium's: 8,034 characters of Wikipedia against 6,503.

Obscura was light on simple pages, but on the five heavy sites it matched Chromium's average memory (518 MiB) and used almost three times its CPU (23.9 against 8.3 CPU-seconds). Each connection runs on one thread, so ten pages on one connection took 11 seconds, against 6.9 over ten. We tested its plain build, not the stealth build. When a page must behave exactly as it does for a person, Chromium is still the safe default.

Lightpanda is a single 72 MiB file, so it is easy to try. The time package provides /usr/bin/time, which reports peak memory:

# as root
apt-get update
apt-get install -y curl time
cd /tmp
curl -fsSL -o lightpanda https://github.com/lightpanda-io/browser/releases/download/1.0.1/lightpanda-x86_64-linux
install -m 755 lightpanda /usr/local/bin/lightpanda

# as the app user
export LIGHTPANDA_DISABLE_TELEMETRY=true
lightpanda version
/usr/bin/time -f 'elapsed=%es maxrss=%MKB' lightpanda fetch --obey-robots --dump markdown --log-level warn https://en.wikipedia.org/wiki/Virtual_private_server > page.md

lightpanda version prints 1.0.1. The fetch prints a few warnings from the page's own scripts, then elapsed=0.29s maxrss=35900KB in our run on a busy CPU (0.16 seconds and about 50 MiB on an idle one), and page.md holds the article as 22,605 bytes of Markdown. Without that variable Lightpanda sends usage telemetry, its README says; --obey-robots makes it respect robots.txt.

Can a local model run on the same VPS?

It runs, slowly, because without a GPU the model runs on the CPU. On 2 vCPUs, Ollama read 104 tokens per second and wrote 37.6 with Qwen2.5 0.5B in about 500 MiB; the 1.5B model read 44.9 and wrote 17.4 in about 1.2 GB with a short prompt. A token is roughly three quarters of a word. One trap: Ollama's first answer had not finished after 5 minutes, and its log showed it starting 8 threads on 2 vCPUs. Setting the thread count to 2, which we then kept with PARAMETER num_thread 2 in a Modelfile, fixed it.

Agent prompts are long. OpenClaw sent 16,482 tokens per step and Browser Use 13,378 to 14,151, which the 1.5B model read at 21 to 26 tokens per second: 7 to 9.5 minutes per Browser Use step. The small models also failed at tools. Claude Code, Hermes and OpenClaw answered in plain text instead of creating the file we asked for, Codex's tool call ended in an error, and Browser Use's model tried to switch to a tab that did not exist. On the third step the kernel killed Ollama at a 2.4 GB peak. Only n8n's single calculator question worked, so keep a general agent's model at an API provider.

Shared or dedicated vCPU for AI agents?

A vCPU is a virtual processor core. On our VPS plans (Nano, Micro, Mini) the vCPUs are shared: your server runs on physical cores that other customers' servers also use. On our VDS plans (Small, Medium, Large) each vCPU is dedicated to you. Most agents spend their time waiting for the model, and then sharing costs little: the gateways and CLIs used 0.1 to 3.6% of one core idle, Paperclip 10%, and a whole turn cost Hermes 7.4 and Claude Code 8.8 CPU-seconds. Browsers come in bursts of 1 to 16 CPU-seconds per batch of pages.

Shared vCPU starts to hurt when the load stops being a burst: a local model that answers all day, a browser agent that loads pages every few seconds for hours, or coding agents running builds in a loop. Dedicated vCPUs then keep the speed steady whatever the neighbours do, as our VPS vs VDS comparison explains.

Choosing a VPS for AI agents: plan and city

Every plan has NVMe storage, unmetered traffic and its own IPv4 and IPv6. You can upgrade later from the client area with a short reboot, so starting one size small is low-risk.

The city matters less than you might think, because a model reply takes seconds and a network round trip takes milliseconds. Pick by where your users and target websites are. In our own ping.pe measurements of 6 October 2026, our Amsterdam VPS answered Frankfurt in 6.6 ms and New York in 72.4 ms, and our VPS in Kosovo answered Vienna in 18.6 ms from Prishtina. For a VPS in Ireland, WonderNetwork's published averages of 6 October 2026 put Dublin about 11 ms from London (WonderNetwork, Dublin to London). Availability by city is on the VPS plans page.

Check your own agent's memory

Your workload is not ours, so measure it. free -m shows the whole server; read the available column, because Linux fills spare memory with cache. For an agent running as a systemd service, here Ollama, these lines give its memory without cache, its peak and its CPU time:

# as root; replace ollama.service with your agent's service name
C=/sys/fs/cgroup/system.slice/ollama.service
echo $(( ( $(cat $C/memory.current) - $(awk '/^inactive_file/ {print $2}' $C/memory.stat) ) / 1048576 )) MiB
systemctl show ollama.service -p MemoryPeak -p CPUUsageNSec

During our Browser Use run this printed 2089 MiB, MemoryPeak=2200088576 (bytes, cache included) and CPUUsageNSec=1834448578000, which is 1,834 CPU-seconds. systemctl status ollama.service shows it rounded as Memory: 2G (peak: 2G). For Docker, docker stats --no-stream shows the working set per container; our idle n8n read 396.5MiB / 3GiB. Measure again while the agent works, because that is when it peaks.

Frequently asked questions

How much RAM does an AI agent need on a VPS?

With a cloud model, 2 to 4 GB for the whole server. In our October 2026 tests on 2 vCPUs, Hermes Agent idled at 216 MiB, n8n with an AI Agent node at 396 MiB, Paperclip at 736 MiB and OpenClaw at 913 MiB. With Debian and working peaks on top, 2 GB covers Hermes or n8n, and 4 GB covers OpenClaw, Paperclip and coding agents.

Do AI agents need a GPU?

No, if the model runs at an API provider such as Anthropic, OpenAI or OpenRouter: all eight agents we measured ran on 2 vCPUs without a GPU. A local model on CPU is the weak spot. On 2 vCPUs, Qwen2.5 1.5B needed 7 to 9.5 minutes per Browser Use step, and the 0.5B and 1.5B models we tried did not finish a tool task in Claude Code, Codex, Hermes, OpenClaw or Browser Use.

Is 1 GB of RAM enough for an AI agent?

For a light gateway, yes. Hermes Agent used 216 MiB idle in our lab and runs on 1 GB once a swap file lets its installer finish. OpenClaw is too big for 1 GB: 913 MiB idle and about 1.6 GiB during a turn.

How much RAM does a headless browser need for an AI agent?

About 150 MiB for Chromium and its Playwright client with no page open, then 40 to 70 MiB per light page and about 100 MiB per heavy page. Ten real pages took 843 to 923 MiB on average and up to 1,103 MiB at peak in our October 2026 tests. Measured as the browser engine alone, Chromium averaged 680 MiB for those ten pages and Lightpanda about 300 MiB.

Can I run several AI agents on one VPS?

Yes, if you add up their working peaks and leave a few hundred MB for the operating system. Measured one at a time in our lab, the Hermes gateway (216 MiB) plus one Hermes chat turn (194 MiB), n8n with an AI Agent node (600 MiB) and a one-page Browser Use agent (443 MiB) add up to about 1.4 GiB, which fits a 4 GB VPS Mini. We did not run them together, so leave headroom, and run each agent under its own Linux user.

Should I choose shared or dedicated vCPU for AI agents?

Shared vCPU suits agents that mostly wait for a cloud model: the gateways and coding CLIs we measured used 0.1 to 3.6% of one core idle, and Paperclip about 10%. Choose dedicated vCPU for a local model, browser agents that load pages all day, or coding agents that run builds in a loop.

Size it from the numbers, then grow

The agent itself is small; the browser and the model decide the size. With the model at an API, a VPS Micro runs a Hermes or n8n agent, a VPS Mini runs OpenClaw, Paperclip or Claude Code, and a VDS Small takes browser fleets and steady CPU. RS Computers runs KVM VPS and VDS servers in Amsterdam, Dublin and Prishtina. Compare sizes and availability by city on the VPS hosting plans page, or message us on Telegram with your agent and we will tell you which plan fits.

← All articles