rent the cores · keep the cash · run your agents anywhere
Turn a ~$5/mo cloud VPS into a dedicated, always-on workbench for Claude Code + Codex — set up by an agent, for your agents.
your laptop --tailscale--> VPS · agents in tmux · docker · builds · 24/7
I couldn't find anything that would justPoint your Claude Code (or Codex) at this and it'll stand up your own cloud VPS as a dedicated AI-agent workbench: install the agents, network it privately, bring over your skills / memory / history / logins, and keep it all synced — so you can run agents 24/7, in parallel, from anything —set this upfor me — so I spent hours figuring it out, and then turned the whole thing into a skill so you don't have to.without dropping thousands on a maxed-out MacBook Pro.
A rented Linux box with 8 cores and 32 GB costs a few dollars a month (or a few cents an hour). Your laptop becomes a thin cockpit; the VPS does the heavy lifting.
Provisions a fresh Linux VPS: git, Node + pnpm, Docker + compose, tmux (OS-aware: Amazon Linux 2023 / Ubuntu / Debian).Installs + logs in Claude Code and OpenAI Codex.Makes the box self-aware— hostname, MOTD, anagent
launcher, andCLAUDE.md
/AGENTS.md
that tell every agent it's a dedicated, headless AI host and how to behave (right package manager, expose ports via tunnels, don't nuke other sessions).Networks it with Tailscale— SSH with** zero public ports**, stable address, works behind any firewall/NAT.** Adds "maxxing" launchers**—claudevps
/codexvps
: one command from your laptop drops you into a persistent tmux session running the top model at max reasoning.cmux cockpit(macOS) to drive many agents in parallel; plain tmux elsewhere.** Reverse accessso the VPS can read/write your laptop's files — including a no-admin path for managed/work laptops**— with a one-command kill switch.** Migrates**your existing skills, memory, conversation history, and logins (GitHubgh
, git, MCP servers).Auto-syncs skills/memory/history between laptop and VPS, automatically.
Every step here was actually run during a real setup. The hard-won gotchas live in references/troubleshooting.md — that file alone is worth the repo.
With Claude Code (recommended):
git clone https://github.com/Kuberwastaken/VPSmaxxing.git ~/Personal-Projects/VPSmaxxing
bash ~/Personal-Projects/VPSmaxxing/scripts/install-skill.sh # installs into ~/.claude/skills (copy; --link to symlink)
Then in Claude Code just say: "set up a VPS for my AI agents" (or run
/vpsmaxxing
). The skill interviews you first — what you have, which agents, auth method, Tailscale, reverse access, migration, sync — then does it, step by step.
Manual (no skill): run the scripts in order on/against your VPS —
scripts/provision-vps.sh
→ authenticate → scripts/setup-agent-env.sh
→ then the references for Tailscale, sync, etc.
| Phase | What | Reference |
|---|---|---|
| Provision | base + Node/pnpm + Docker + tmux | |
01 |
02
agent
/self-briefing03
04
claudevps
/codexvps
, top model + reasoning05
06
localhost:PORT
testing via tunnel07
08
09
10
Architecture & mental model: references/00-architecture.md.
Researched June 2026; prices change — every figure links to its source. Pick by how you'll use it:
Cheapest always-on:Contabo Cloud VPS 30— 8 vCPU / 24 GB / 200 GB NVMe for~$16/mo flat, unlimited traffic.** Best performance/$ (if your stack is ARM-clean):Hetzner CAX41— 16 vCPU / 32 GB ARM for~$47/mo**.** Free, if you can get capacity:Oracle Cloud "Always Free" Ampere A1 — up to4 vCPU / 24 GB, $0 forever(ARM; fight for stock). Simplest managed:DigitalOcean/ Vultr**(great UI/API).** Bursty/occasional:an AWS/GCP/Azurehourly box that you stop when idle**(pay only for disk while stopped).
The 24/7 trap:hourly clouds look cheap per-hour but an always-on AWSm6a.2xlarge
(8 vCPU/32 GB) is ≈$252/month. Either go flat-rate, or stop-when-idle. (Flat-rate VPS keep billing even powered off — snapshot+destroy to truly stop paying.)
Pricing captured
June 2026. EUR figures converted at≈ €1 = $1.14([ECB/Trading Economics, 30 Jun 2026]); USD is approximate and region/VAT-dependent.Hetzner raised CPX/CCX cloud prices ~110–175% on 15 June 2026([Hetzner price-adjustment notice]), which reshuffles the value ranking below.
| Provider | Plan | vCPU / RAM | Disk | ~USD/mo | Regions | Link |
|---|---|---|---|---|---|---|
| Hetzner Cloud | ||||||
| CPX42 (AMD, shared) | 8 / 16 GB | 320 GB NVMe | ~$79 (€69.49) | |||
| DE, FI, US, SG | ||||||
Hetzner Auction**~$51**(≈€45)hetzner.com/sb** Contabo****~$16**(€14.00)contabo.com/vps-server** Netcup****~$18 net**(€16.18 ex-VAT)netcup.com/server/vps** OVHcloud****~$23**($23.37)ovhcloud.com/vps** Hostinger****~$26 promo / ~$50 renew**hostinger.com/vps-hosting** Scaleway****~$93**(€81.90) + storage/IPv4scaleway.com/pricing/virtual-instances** Bandwidth at a glance:** Contabo 600 Mbit/s unlimited traffic; OVH 1.5 Gbps unmetered; Netcup unmetered; Hetzner CPX42 1 Gbit/s + 20 TB/mo included (overage billed); Hostinger KVM 8 32 TB; Scaleway billed PAYG with egress included in list price.
Standout pros / cons
Hetzner— Pros: best-in-class hardware, fast NVMe, hourly billing, real EU/US DCs. Cons: the June-2026 hike made x86 CPX/CCX pricey (CPX42 ~$79; dedicated CCX33 8 vCPU/32 GB ~$158,costgoat Jun 2026). TheARM CAX41 (16 vCPU / 32 GB, €40.99 ≈ $47) survived as a value monsterif your toolchain is ARM64-clean— most agent CLIs and Docker images are. TheServer Auction is the cheap path to a real dedicated box (no noisy neighbors, unlimited traffic), but stock/specs fluctuate (Server Radarhelps).Contabo— Pros: rock-bottom flat pricing, generous RAM/disk, no setup fee, unlimited traffic, global DCs. Cons: oversubscribed shared cores and 600 Mbit/s port mean weaker single-thread/IO than Hetzner/Netcup; cheapest rate wants a 12-month term.Netcup— Pros:** DDR5 ECC RAM**+ huge 512 GB NVMe at a low price, snapshots, hasn't hiked in 2026. Cons: EU-centric, prices quoted** incl. 19% VAT**(non-EU/business pay the ~€16.18 net), 1- or 12-month terms.** OVHcloud**— Pros: predictable flat pricing, unmetered 1.5 Gbps, anti-DDoS + daily backups included, wide DC footprint. Cons: support reputation is hit-or-miss; mid-tiers are middling on raw CPU.Hostinger— Pros: cheappromo, 32 GB RAM + 32 TB traffic, beginner-friendly panel, AMD EPYC. Cons:renewal nearly doubles(~$50) and the headline price needs a long up-front term.** Scaleway**— Pros: genuine cloud (API, snapshots, EU data sovereignty), true hourly PAYG. Cons:** far pricier**for sustained 24/7 use and block storage + IPv4 are billed separately — not a budget pick.
Best value pick: Contabo Cloud VPS 30 — 8 vCPU / 24 GB / 200 GB NVMe for ~$16/mo flat, unlimited traffic (contabo.com) is the cheapest way to keep Claude Code + Codex agents running 24/7; step up to Hetzner's ARM CAX41 (16 vCPU / 32 GB ≈ $47) for the best raw performance-per-dollar if your stack is ARM64-friendly, or Netcup VPS 2000 G12 (~$18, DDR5 ECC) for the best price/quality balance on x86.
These are the big, well-supported clouds for running a Linux box with Claude Code + OpenAI Codex on it. Pricing verified June 2026; every figure links to its source. Target tier: ~4–8 vCPU / 16–32 GB RAM.
| Provider | Instance (plan) | vCPU / RAM | Disk | ~USD/mo | ~USD/hr | Link |
|---|---|---|---|---|---|---|
| DigitalOcean | ||||||
| General Purpose Droplet | 8 / 32 GB | 100 GB SSD | $252 | |||
| $0.375 | ||||||
Vultr**$160**pricing** Akamai Linode****$192**pricing** AWS Lightsail****$164**pricing** AWS EC2 (on-demand)~$252** if 24/7pricing·m6a.2xlargeHetzner Cloud~$150³ (€138.49)price notice Google Cloud**~$196** if 24/7GCE pricingMicrosoft Azure**~$252** if 24/7D8as_v5¹ Lightsail bills hourly but is capped at the flat monthly price. ² EC2 m6a.2xlarge has no local disk — add EBS (100 GB gp3 ≈ $8/mo). ³ Hetzner bills EUR; USD approx at €1≈$1.08. ⁴ GCE/Azure prices are compute only — disk + egress billed separately.
Notes & gotchas
DigitalOcean— simplest managed experience, great docs/UI/API, per-second billing with a monthly cap. A CPU-Optimized 8 vCPU / 16 GB is**$168/mo** if 32 GB is overkill. Con: dearer than budget VPS; bandwidth overage extra. (src)Vultr— best mainstream value at this tier, 32+ regions.** High Performance NVMe 8 vCPU / 16 GB = $96/mo**. Con: a powered-off instance still bills (resources reserved). (src)** Akamai Linode**— clean predictable pricing, generous transfer; Shared 16 GB = 6 vCPU / 16 GB /$96/mo. Dedicated-CPU plans cost more but kill noisy-neighbor jitter. (src)** AWS Lightsail**— flat AWS-flavored VPS, 7 TB bundled transfer. Con: fixed bundles, lower ceiling than EC2 — "set and forget," not bursty scaling. (src)Hetzner Cloud— historically the price/perf champ, but a** 15 Jun 2026 hike raised CCX ~+120% / CPX ~+209%**. Still good NVMe + EU residency, fewer regions (DE/FI/US/SG). (src)Google Cloud—e2-standard-8
is the value pick (~$196/mo); newerc4-standard-8
is faster but ~$294/mo. Sustained/committed-use discounts help. (src)Microsoft Azure—D8as_v5
(AMD) $0.344/hr; best if you're already in Microsoft/Entra; reserved instances cut cost a lot. (src)
The 24/7-cost trap. Hourly clouds (AWS EC2, GCE, Azure) look cheap per-hour but get expensive run around the clock: AWS m6a.2xlarge (8 vCPU/32 GB) = $0.3456/hr ≈ $252/mo if always on (Vantage); GCE e2-standard-8 ~$196/mo, Azure D8as_v5 ~$252/mo behave the same.
Stop-when-idle (the money-saver). On EC2/GCE/Azure you can stop the instance when not coding — while stopped you pay only for the attached disk (EBS/PD/managed-disk, ~$8–12/mo for 100 GB), not compute. An agent box used ~3 hrs/day can cost $30–40/mo instead of $250+. Caveats: a static/Elastic IP may bill while stopped, and flat-rate VPS providers (DO, Vultr, Linode, Lightsail, Hetzner) keep charging when powered off — to stop paying there you snapshot + destroy, then rebuild.
Best for managed/scalable: AWS EC2 (m6a.2xlarge + stop-when-idle) for max flexibility and pay-for-what-you-use, or DigitalOcean for the simplest predictable flat-rate managed VPS.
Running Claude Code or OpenAI Codex on a VPS is cheap because the heavy lifting (the model) runs on Anthropic's/OpenAI's servers — your box is mostly a thin shell for git
, package installs, builds, and the agent process. That means you can get away with very little, and there are a few genuinely-free ways to do it.
| Option | Specs | Cost | Caveat | Link |
|---|---|---|---|---|
| Oracle Cloud "Always Free" (Ampere A1, ARM) | ||||
| Up to 4 OCPU / 24 GB RAM + 200 GB block storage + 10 TB/mo egress | $0 forever | |||
| ARM, not x86. Frequent "Out of host capacity" in popular (esp. US) regions — EU/APAC provision faster. As of June 2026 the headline was trimmed to 2 OCPU / 12 GB for new free-tier signups (PAYG-upgraded accounts may still keep 4/24; enforcement is inconsistent). Idle instances can be reclaimed. | ||||
1 GB RAM each — too small for real builds; useful only as a control node.OCI free breakdownGCP "Always Free" e2-micro****1 GB RAM/ 30 GB disk** us-west1 / us-central1 / us-east1 only.**1 GB RAM OOMs onnpm install
/docker — needs swap. New accounts also get a $300 / 90-day trial credit on top.cloud.google.com/freeAWS Free Tier (new accounts)****$200 total)** New model = ~6 months**, expires when credits run out (accounts created after 15 Jul 2025). Not "always free."AWS Free Tier·announcement1 GB) + 30 GB EBS** 12 monthsbefore 15 Jul 2025**; 12-month clock then bills at PAYG. 1 GB RAM is tight.Free Tier FAQ** Azure free accountB1S**(1 vCPU / 1 GB) Linux**$200 credit expires in 30 days.** B1S is 1 GB. Disks/public IP/logs can bill even on "free" VMs.Azure free account·free servicesfly.io****2 VM-hrs or 7 days; cheapest always-on ~$2/mo** No real free tier in 2026**(old Hobby allowances are legacy-only). A realistic small always-on box lands at**~$8–25/mo** once egress is counted.fly.io/pricingHetzner CAX11 (ARM)2 vCPU / 4 GB / 40 GB / 20 TB traffic€3.79/mo ($4.50) ARM(Ampere) — watch x86-only Docker images/binaries. ARM available in DE/FI only. Prices rose mid-2026.hetzner.com/cloud·price changeHetzner CX22 (x86)€4.49/mo ($5)hetzner.com/cloud** RackNerd (annual)$1.49–2/mo billed yearly ($18/yr) renewal price is higher than promo**; quality varies by deal.racknerd.com** Bottom line on "free":** Oracle's Ampere A1 is the only free tier that's actually big enough to be comfortable — but you have to fight for capacity and accept ARM. Every other free tier (GCP/AWS/Azure micro) is 1 GB RAM, which will OOM on real package installs and Docker builds unless you add swap and keep it to one light session. If free is fragile, Hetzner CAX11 at ~$4.50/mo is the dependable floor.
Both agents run fine on ARM: OpenAI Codex ships an aarch64-unknown-linux-musl
build and Claude Code installs on ARM64 Linux — so the tools themselves aren't the ARM problem; your project's toolchain (some Docker images, prebuilt binaries, ML wheels) is. (Codex releases, Claude Code on Arm)
Claude Code and Codex are network-bound to the model API, not CPU-bound. The model does the thinking remotely; your VPS only does the "developer machine" work — cloning repos, npm/pip/cargo
installs, Docker builds, running tests/linters, language servers, and holding several agent sessions open at once. So size for builds and parallelism, not for inference.
Minimum (single session, light projects): ~2 vCPU / 4–8 GB RAM, 40 GB disk. Handles one agent, normal git/package work, and small test runs. Avoid 1 GB tiers —npm install
and Docker will OOM. If you're stuck on a 1 GB free tier, add2–4 GB swap as a crutch.*Fits: Oracle A1 (2/12), Hetzner CAX11/CX22.*Comfortable (parallel agents, Docker, big repos): ~4–8 vCPU / 16–32 GB RAM, 80 GB+ disk. Run multiple agent sessions, Docker builds, language servers, and heavier test suites without thrashing.Fits: Oracle A1 (4/24), a Hetzner CCX/CPX, or a hyperscaler box you stop when idle.
Region & latency. Two different latencies matter, and the one you feel is your terminal/SSH round-trip — so put the box near you. Latency to the model API matters less: the agent streams tokens, so sustained throughput dominates over first-token RTT, and Anthropic/OpenAI endpoints are globally edge-routed. A US region shaves a little off first-token time, but "near me" wins for the interactive feel. Default: closest region to you; US is a fine tiebreaker.
Money-saving tactics.
Always-on dev box → flat-rate provider. Hetzner/RackNerd-style fixed monthly pricing is far cheaper and more predictable than hyperscaler hourly rates (no egress surprises). The right default for a personal agent box you SSH into daily.Bursty/occasional use → hourly cloud + stop-when-idle. AWS/GCP/Azure only beat flat-rate if you actuallyshut the instance down when not coding (a cron/script that stops it saves ~70% vs 24/7). Leave one running overnight and the math flips against you.Go ARM for cost. Ampere/Graviton are ~20–40% cheaper per unit of performance and run the agents + most Node/Python/Go/Rust fine. Only avoid ARM if your project pullsx86-only Docker images or prebuilt binaries.** Spot/preemptible: skip for interactive work.60–90% off, but the provider can kill the VM mid-session — fine for checkpointed batch jobs, painful for a live agent. Storage ≥ 40–80 GB.**node_modules
, Docker layer caches, and multiple repo clones balloon fast; 20–30 GB free-tier disks fill within a couple of projects. On hyperscalers, watchblock-storage and egress billing separately from the VM.
LAPTOP (cockpit) VPS (workbench)
cmux/tmux · editor · browser ── Tailscale ──▶ agents in tmux · docker · builds
localhost:5173 ◀── ssh tunnel ────────────────── dev server :5173
files ◀──────── reverse ssh ──────────────────── ssh mac (clone/copy/rm)
Laptop drives; VPS works; everything's on a private Tailscale mesh; agent state syncs both ways. Full rationale in references/00-architecture.md.
- The box runs agents in
YOLO mode on purpose — it's a disposable, isolated workbench. Keep real work in git. Reverse access re-couples the blast radius to your laptop (a runaway agent could delete laptop files). Scope it to a shared folder if unsure, and keep
revoke-vps-access
handy.Never paste secrets into a chat. The skill pipes credentials device-to-device and never prints them; if a key leaks, rotate it.- Tailscale means you can keep port 22 closed to the world entirely.
SKILL.md the Claude Code skill (interview + orchestration)
references/00..10 step-by-step guides, OS-aware, generalized
references/troubleshooting.md every trap that cost hours
scripts/ runnable: provision, setup-agent-env, agent-sync,
mac-user-sshd (no-admin reverse access), install-skill
Built by generalizing a real, end-to-end setup (AWS Amazon Linux 2023 + a managed macOS laptop) into something anyone can re-run. PRs welcome — especially provider price updates and more OS branches.
Made because renting 8 cores should be easier than affording 8 cores.
MIT © 2026 Kuber Mehta. Use it, fork it, share it — then go set up your VPS.