Run Claude Code and Codex on a Remote VPS Without Going Broke: 2026 Provider Rankings After Hetzner's Price Hike

The same always-on agent workbench — roughly 8 vCPUs and 16 to 32 GB of RAM running Claude Code and Codex 24/7 — currently costs anywhere from $16 a month to $252 a month depending on which provider column you pick. That 15x spread is new. Until June 15, 2026, the default answer was a Hetzner CPX cloud box and nobody thought twice; then Hetzner raised its shared and dedicated x86 lines by 110 to 175 percent and more, and the whole value table had to be rebuilt from scratch.

Someone did rebuild it. The vpsmaxxing skill — an open-source skill that gets an agent to set up Claude Code and Codex on a remote VPS for you — ships a June 2026 provider ranking priced for exactly this workload: a persistent, always-on box where agent loops live. Here is that ranking condensed to the decision that matters, with the metered-sandbox breakeven math the ranking implies but never states. Prices below are per month for the workbench tier unless noted, captured June 2026 with euros converted at about $1.14.

Three new defaults fall out of that table: Contabo at ~$16 for the cheapest always-on seat, Netcup at ~$18 for the best price-to-quality balance on x86, and Hetzner's ARM CAX41 at ~$47 for the best raw performance per dollar if your toolchain is ARM64-clean. The Hetzner auction box at ~$51 is the floor for a real dedicated machine with no noisy neighbors. Everything from Vultr upward is you paying for brand, region coverage, or an API — not for running agents cheaper.

What June 15, 2026 broke​

Hetzner's price adjustment hit its two most popular x86 families and spared everything else. Blended across families and regions the increase runs about 110 to 175 percent and beyond: dedicated CCX instances rose 113 to 173 percent, shared CPX instances rose 144 to 192 percent, and the steepest single cell — CPX31 in the US region — climbed roughly 2.98x. The ARM-based CX and CAX lines were untouched, which is why a 16-vCPU ARM box now undercuts an 8-vCPU x86 box from the same company.

Concretely: a CCX33 (8 dedicated vCPUs, 32 GB) that used to anchor the "serious agent box" tier now lists at €138.49, about $150, while the smaller CCX13 jumped from €15.99 to €42.99. The new prices apply to all new orders and instance rescales, so anyone re-provisioning agent infrastructure after mid-June reprices immediately. Third-party breakdowns like Northflank's put the damage in team terms: three mid-tier instances that cost about €187 a month now cost about €415 — an extra €2,736 a year for identical compute.

This is why the ranking above had to exist at all. "Just get a Hetzner CPX" was good advice for years because Hetzner combined best-in-class NVMe hardware, hourly billing, and 20 TB of included transfer at prices nobody matched. After the hike, the hardware is still excellent but the x86 price anchor is gone — and the replacement default depends on what tradeoff you will accept, which is the next section.

Reading the ranking: what the cheap rows cost you​

A price table without the catches is a trap. Each budget row buys its number with a specific compromise:

• Contabo (~$16): shared, oversubscribed cores on a 600 Mbit/s port. Single-thread performance and IO lag Hetzner and Netcup noticeably, and the headline rate wants a 12-month term. As the ranking notes, it is the cheapest way to keep agents running 24/7 — not the fastest.
• Netcup (~$18 net): EU-centric terms, VAT-quoted prices. The DDR5 ECC RAM and 512 GB of NVMe at this price are unmatched, but list prices include 19 percent German VAT (non-EU businesses pay the lower net figure), and terms run 1 or 12 months. No 2026 hike so far.
• OVHcloud (~$23): flat pricing with unmetered 1.5 Gbps, anti-DDoS, and daily backups included. The compromise is operational reputation — support is famously hit-or-miss — and middling raw CPU on the mid tiers.
• Hostinger (~$26 promo, ~$50 renew): the renewal trap. AMD EPYC hardware, 32 GB of RAM, and 32 TB of traffic look unbeatable until the promo expires and the price nearly doubles, with the headline number locked behind a long up-front term. Price the renewal, not the landing page.
• Hetzner Auction (~$51): fluctuating stock, DE/FI only, tiered support. You get a real refurbished dedicated box — no noisy neighbors, unlimited traffic — but specs and availability change daily (trackers like Server Radar exist for this reason), and boxes under €49 get lower support priority.
• Scaleway (~$93 plus extras): genuine cloud, wrong workload. Real API, snapshots, and EU data sovereignty with true hourly PAYG — but block storage and IPv4 bill separately, and sustained 24/7 use is far pricier than any flat VPS. A budget pick it is not.

The honest read: there is no $16 row without a catch, but every catch above is a known quantity you can plan around — unlike a metered bill, which is a variable you cannot. That is the actual decision, and it deserves its own arithmetic.

The idle-RAM math at two tiers​

An always-on agent loop pays for idle RAM, not active tokens. The model bill meters what the agent thinks; the infrastructure bill meters the box sitting warm between thoughts — holding checkouts, language servers, Docker layers, and tmux sessions so the next prompt starts instantly. Flat VPS pricing charges you for that warmth once. Per-second sandbox pricing charges you for every second of it. Run the numbers at two tiers using E2B's published rates — $0.0504 per vCPU-hour plus $0.0162 per GiB-hour, billed per second — against flat boxes:

Tier 1: 8 vCPU / 32 GB. Metered, that is 8 × $0.0504 + 32 × $0.0162 ≈ $0.92 per hour, or about $673 a month if the sandbox never sleeps. Flat, it is $16 to $51. The metered option only wins if the box runs less than roughly 2 to 8 percent of the month — a few dozen hours against 730. A persistent Claude Code session you dip into daily clears that bar in the first week.

Tier 2: 16 vCPU / 64 GB. Metered: 16 × $0.0504 + 64 × $0.0162 ≈ $1.84 per hour, about $1,345 a month at 24/7. Flat, an auction-class box at ~$51 a month works out to about $0.07 an hour — roughly six euro-cents, more than an order of magnitude under a euro an hour. Breakeven sits near 4 percent duty cycle. And that metered column excludes plan floors: E2B's 24-hour sessions require the $150-a-month Pro tier, and Hobby sandboxes cap at one hour — fine for a run, useless for a loop.

This is the same economics that governs tenant-workload bin-packing on any PaaS: utilization is the whole game, and anything parked above single-digit duty cycle belongs on flat capacity. The "per-token managed agent cloud" framing obscures it by inviting you to compare token prices while the meter runs on compute. Compare compute to compute and the crossover is stark — persistent loops live on flat boxes; metered sandboxes are for execution bursts, which is exactly where they still win.

Where the managed sandbox still wins​

None of the above is an argument against E2B, Daytona, Modal, or their peers. It is an argument about which workload goes where — and the split is a trust boundary, not a price curve.

Your persistent agent box holds your credentials: GitHub tokens, API keys, shell history, Tailscale identity, the synced skills and memory that make the agents useful. Untrusted generated code — the output of the very agents you run, plus anything fetched from the network during a run — should never execute in that blast radius. That is what Firecracker-microVM sandboxes are for: sub-second boot (under 125 ms per microVM in Firecracker's NSDI design, 150–200 ms cold boot on E2B), separate-kernel isolation, filesystem and network policy per run, and billing that stops the moment the sandbox is paused or killed. A disposable per-run sandbox with a 24-hour ceiling is the right home for "run this generated script and report back"; the persistent VPS is the right home for the loop that asked.

The concrete rule: loops live flat, runs live metered. Park the long-lived session — the tmux-persisted Claude Code or Codex process with your context — on the $16–$51 box. Fan out untrusted execution to per-second sandboxes that vanish when the run ends. Teams that invert this either pay $673 a month to keep a sandbox warm or run attacker-shape code next to their credentials. Both failure modes are visible in the pricing pages before they happen in production.

The access shape, briefly​

For completeness, the pattern every remote-agent setup converges on, in three bullets rather than a tutorial:

• Private network first. Tailscale (or equivalent) with SSH over the tailnet and zero public ports — no exposed SSH, stable addresses behind any NAT. Every maintained setup guide (remote-claude, coding-agents-on-a-vps, remote-devbox) treats this as step zero, not an optimization.
• Persistence across disconnects. tmux (or Zellij) so sessions survive a closed laptop lid, plus mosh for roaming connections. The laptop becomes a thin cockpit; the VPS holds the state.
• Automation exists. The vpsmaxxing skill interviews you about agents, auth, networking, and migration, then provisions the box, installs both CLIs, networks it, and syncs skills, memory, history, and logins — the whole checklist as one agent-driven run instead of an afternoon of shell history.

Park the loop, meter the run​

The placement decision after the 2026 repricing fits on an index card. If the workload is a persistent agent loop running more than a few percent of the month, put it on flat capacity: ~$16 Contabo for the cheapest seat, ~$18 Netcup for x86 quality-per-dollar, ~$47 Hetzner ARM for performance, ~$51 auction for dedicated iron. If the workload is a burst of untrusted execution, pay per second for a Firecracker sandbox and let it die when the run ends. Never pay $1.84 an hour to keep a loop warm, and never run generated code next to your credentials to save the price of a sandbox.

The deeper lesson travels beyond agent hobbyists. Any platform that hosts other people's always-on processes — PaaS tenants, preview environments, scheduled agents — faces the same idle-RAM ledger, and the operators who win are the ones who bin-pack the flat capacity ruthlessly while metering only the bursts.

Hetzner's hike just forced every agent builder to learn that ledger personally. The $16-to-$252 table above is the cheat sheet; the 4-percent breakeven is the principle. Keep both where you can see them the next time a provider reprices under you.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with AI agents as first-class operators. Star the repo on GitHub or deploy your first app today.