Run your own personal AI agent (OpenClaw) on a VPS — measured

Disclosure: this article contains affiliate links. If you buy through them, Rack at Home may earn a commission at no extra cost to you. We test everything we recommend.

Tested on 2026-10-27, end-to-end, on our own hardware.

AI agents are past the demo phase. Tools like OpenClaw sit on a server, keep their memory, and do actual chores — check things, answer things, run things — while you sleep. The catch is placement: an agent on your laptop is asleep when your laptop is. The fix is the boring one — a small VPS that runs 24/7. We installed OpenClaw on a modest Ubuntu VM and measured the whole thing: install time, memory under load, what one turn costs, and which plans it actually fits on.

Start here: make sure it's the real OpenClaw

Before any install command, this matters. OpenClaw is a genuinely young project: the openclaw.ai domain was registered 2026-01-29 and the GitHub org was created 2026-01-04 (we checked both live — RDAP for the domain, the org page for the repos; 98 public repositories as of our test date). Young and popular is exactly the window where impostors move in.

While researching, we watched a fork of the project ranking in search results next to the original, and found a lookalike GitHub org named after the year with big "Download" buttons on it. We won't link either one, and neither should you. Our rule, and the one we'd give you: install from the official package registry (npm), verify the project's GitHub org — its creation date and repo history tell you more than any landing page — and never install a fresh tool from a "download" page that a search engine handed you. For a three-month-old project, a polished download site is a warning sign, not a reassurance.

Install: 36 seconds, then the config detour

The test bench was a small KVM box running Ubuntu — 4 vCPU, 8 GB RAM, the kind of machine any of the plans below provide. Node 26 and npm 12 were already on it:

npm install -g openclaw@latest --allow-scripts=openclaw

That took 36 seconds and installed version 2026.10.8. Genuinely that fast. What the tutorials don't tell you is what happens next. The first gateway start refused outright with "Missing config" — the daemon won't run until you either run openclaw setup or explicitly allow an unconfigured start. A second surprise: npm flagged blocked install scripts for several dependencies (native helpers like koffi and protobufjs). That's the package manager sandbox doing its job; read the warnings instead of reflexively loosening it.

Honest elapsed time from empty VM to one working agent turn, config detours and all: about 15 minutes. The install is not the work. The configuration is.

Point it at a model (and why the obvious flags don't work)

An agent is only as cheap as the model behind it. OpenClaw resolves a cloud API model by default — and here's the pitfall that cost us detour time: the --model flag and the OPENAI_BASE_URL environment variable are both silently ignored. The model catalog is static; refreshing it still returns the built-in cloud roster. What actually works is editing the config file: replace the model catalog and point the provider's base URL at your own endpoint, with the API key inline. We pointed it at a local, self-hosted open-weights model on our test network to keep the whole test at $0 in API fees.

If you plan to run against a self-hosted or third-party model, budget for reading the config docs. The flags that look obvious do nothing, and nothing warns you.

What one agent turn really costs: ~14,700 tokens

We asked the agent something trivial — two sentences of arithmetic plus a lookup. Numbers from the pinned local model run:

• 24.2 seconds of agent work (31 seconds wall time including CLI startup).
• 14,712 input tokens, 54 output tokens. Stop reason: clean.

Read that input number again. The task was about thirty tokens. Everything else is agent scaffolding — instructions, tool definitions, memory — shipped on every single turn. Two consequences worth planning for. First, if you pay per token on a cloud model, every command carries roughly the same base cost no matter how small the ask; cheap daily chores quietly stop being cheap. Second, on self-hosted models, that overhead eats your context window: ours was 131k tokens, so the scaffolding alone claimed over 10% of it before the conversation started.

Sizing: 1.1 GB idle, 1.9 GB under load

Memory, measured with the gateway running and the agent quiet: 1.08–1.16 GB resident. During an active turn: 1.86 GB peak. CPU is unremarkable — the heavy lifting is the model, wherever that lives; the box itself mostly waits.

The sizing verdict, stated plainly: 8 GB is comfortable — the agent plus your model endpoint (if self-hosting a small one) plus headroom. 4 GB is workable with care — the agent alone fits, but nothing much else shares the box. Below 4 GB, don't bother.

Real monthly cost: the plans it actually runs on

We pulled live public pricing for the three budget hosts people always ask about, on 2026-10-27. Prices below are what the pages said that day; the software itself is $0 — you're only paying for the box.

The fine print is the story. Contabo's $5.28 and Hostinger's $6.49 are lock-in prices — two-year prepay, and Hostinger renews at nearly double. Vultr costs 3–6x more at the 8 GB tier but bills hourly with no term, which is the right shape if you want to churn experiments. Straight answer: the cheapest box that fits our sizing verdict is an ~$5–7/month 8 GB plan; the cheapest box that runs the agent at all is a 4 GB plan around $5–6.50, with the "care" caveat from above.

How we measured

Method, so you can repeat it: we installed on a clean Ubuntu KVM VM and timed the npm command wall-clock, then sampled the gateway's resident memory from /proc every few seconds across a quiet ten-minute window for the idle figures, and again while the agent executed a real turn for the active peak. The turn ran against our own self-hosted open-weights endpoint, so token spend stayed zero; usage counters came from the agent's own machine-readable output rather than an external monitor. Plan prices were read from the hosts' public pricing pages the same day — not from cached reviews or reseller blogs. Every number on this page came from that single sitting; nothing is quoted from someone else's bench.

Pitfall roundup

• Impostors first, project second. Forks ranking in search, lookalike orgs with download buttons — verify the org and registry source before installing.
• First start refuses. "Missing config" until you run setup or allow unconfigured mode.
• Model overrides ignored. --model and OPENAI_BASE_URL do nothing; edit the config file.
• npm blocks dependency scripts. Expected sandbox behavior — read, don't reflexively bypass.
• ~14.7k input tokens per turn. Flat overhead on every ask; it changes the economics of both API-billed and self-hosted models.

Verdict

The install is 36 seconds and free; the real work is avoiding the fake downloads, fighting the config to get your own model attached, and sizing the box around the 1 GB idle / 2 GB active footprint. A $5–7/month VPS runs a 24/7 personal agent without drama once configured. OpenClaw is three months old — expect sharp edges, read the config docs, and don't trust a search result that wants you to click "Download."

Operationally, one habit outweighs them all: archive the agent's own usage output and skim it weekly. Scaffolding overhead creeps upward as you bolt on extra tools, memory files and instructions — the ~14.7k tokens we printed is the floor, not the ceiling. A turn that balloons toward forty thousand is the quiet way a hobby deployment starts invoicing like a small business. Log first, tune second.