I stopped using the best way to run coding agents
Since late 2025 I've run coding agents in containers, on shared VMs, on a system I built and on Amp. This is where they run now, and why their builds run somewhere else.
There are so many ways to run coding agents, and unfortunately I think I need to stop using the best approach to run coding agents.
In my opinion the best setup is fully hosted agents. You start a task, a fresh machine appears with your code on it, the agent works there, and the machine with all its changes and environment goes away when it's done. I rolled my own solutions but never quite committed to upkeeping them long-term, so when I first tried Amp Orbs, I fell in love. Amp does this best with machines it calls orbs. They have a great interface for doing this exactly how I'd want.
But my agents are back on my own VMs now. This is the year that got me there, starting in late 2025. It comes down to two decisions I used to treat as one. Subscriptions decide where my agents can run. Compute decides where their builds run.
Route. Stop 1 is Everything at home: Containers, Shared VMs and My own system. Stop 2 is VMs and orbs, between Everything at home and Fully hosted. Stop 3 is Fully hosted: All on Amp. Stop 4 is Agent at home, builds rented: T3 Code + Boat.
- Up the diagonal. Every move changed the agent and the builds together.
- The last move. Subscriptions and control brought the agent home. Compute kept the builds out.
What I wanted in 2025
I started by running Codex and Claude Code fully isolated in custom Docker containers and managing them through a web interface (kinda like Amp). I wanted three things from them.
- One-off. A container starts for a task and gets thrown away after.
- Isolated. The agent gets only the keys and the code it should have, and nothing else.
- Room to run whatever it needs. One agent starting Postgres or using tons of memory shouldn't step on another agent's toes.
That list hasn't changed. Every setup I've used since has been a different way of exploring the best trade-offs for it.
Building it myself
Containers gave me the building blocks, but the tooling and functionality around them was mine to build. That took too much time away from building actual things. Every issue that came up was mine to fix and every few weeks I'd have to change its functionality to match the new models and harness features.
So... after a month or two of that experiment, I moved to shared VMs. Several agents worked on the same machine, side by side. I ran the Amp CLI there next to Claude Code or Codex, depending on which model was on top at the time.
That trade gave me my time back but cost me a lot of the above list. Nothing was one-off, and nothing kept one agent's Postgres or memory away from another's.
Once GPT 5.6 launched I tried one more time to build my own remote agent system. It worked similarly to the way Amp does. It was less polished, and all of it ran locally on my homelab with a TypeScript and Go system with E2B Embed for running the agents. Again I ran into those exact same issues. It worked great for the existing harnesses but fell behind a few weeks later. It was taking too much time away from building to maintain feature parity and fix one-off bugs.
Amp, on and off
I used Amp from its early days in the CLI, but I had to move away when subscriptions became really important. It was impossible to rationalize paying API prices when subscriptions were subsidized so much.
Then Amp announced orbs in June. It was exactly what I was wanting because every new thread gets a fresh remote machine with your code, plugins and tools on it, billed by the minute. I tried them shortly after the announcement and fell in love. It was my list from 2025, and I hadn't needed to build any of it, I could just pay a small subscription and it was all handled by an awesome team.
For a while I ran a hybrid, with some work on my own machines and some on Amp. They didn't have Mac VMs at the time, so I briefly used Amp runners for my Mac app builds and testing on my own Mac. When Amp added support for Claude plans, I moved over fully.
I still think it's the right design. Fully remote compute is where I want to end up. But unfortunately getting access to Orbs pushed me to a new constraint, so I left Orbs behind.
Subscriptions were the reason, again... In my homelab environments I run CLIProxy, a proxy that sits in front of my model subscriptions. My agents go through it in place of logging in to a provider themselves, so every plan I pay for gets used automatically at the right time. I ran into issues where I started to really need all of my subscriptions accessible and on Amp they couldn't do that.
The second reason is control. I want to customize how my environment works, and swap out or adjust any piece of it. I also got really interested in using other agents (Grokbot, Dot, etc) to run my agents through MCP.
I had been using T3 Code on and off to make working with Claude Code and Codex easier on my remote VMs. Its MCP is laid out way better than Amp's and allows the agent calling it to have much better access and control to what's actually going on. Along with that calling subagents from a different model family is nicer there too.
Ten agents, one frozen VM
In late October when I got fed up with juggling subscriptions inside Amp, I decided to commit and moved everything over to T3 Code full time, on a few VMs I run myself in my homelab. That fixed one problem but put me back on shared machines, and back to the problem shared machines have.
The next day I had ten agents running and most of them triggered tests at the same time, and the VM froze. It happened a few more times. None of it was unusual work and none of this was a problem in Amp. These were normal projects running normal builds and test suites. Ten of those at once just take a ton of resources.
Then I had an epiphany, I could offload the compute heavy commands to external compute while keeping the agent local. The fix was a global skill that every agent on every machine follows. It tells them to send heavy work to Boat, which rents cloud VMs billed by the second.
The rule is short. The code stays in the checkout on my VM, and so do commits and pull requests. For a full test suite, a big build or anything with Docker, the agent pushes the code to a fresh sandbox, runs the job, brings back the results and deletes the sandbox. The sandbox gets none of my keys by default.
Here is a trimmed part of it.
## Where the work lives
- The repository stays checked out in your T3 worktree. Edit, diff, commit,
push and open PRs there, never from a sandbox. [...]
- Send code to a sandbox, run the job, bring back what you need (exit code,
logs, test reports, built artifacts), then delete the sandbox.
## When to use it
Use a sandbox for:
- builds or test suites that take more than a few minutes, or would load the
machine for a long time;
- running several builds or test runs in parallel, for example one per
subagent;
- Docker work, untrusted code, and installing unfamiliar tools; [...]
A full test suite [...] counts as heavy even when it is quick on this
machine's warm cache. [...] Several agents running suites at once is what
overloads the machines.
Run it locally instead when the job is small: one package's tests, a lint, a
type check or a one-file build.
The simplest job is one command.
boat run --no-env --push . --timeout 1800 -- npm test
That is the 2025 list again, for the part of the work that needs it most. Every test run gets a one-off machine with its own Postgres and its own memory, and none of my keys.
What it costs, and what would move me
Boat costs me $20 a month right now. I'll likely move to the $100 plan as I scale up and hit the limits of the $20 one. Getting this compute is a big unblocker for running more and more agents in parallel.
The split has other costs. A sandbox can't reach my private network, so anything that needs it stays on the VM. I keep a saved snapshot for some projects, with the toolchain and dependencies already installed so a sandbox starts warm. Those snapshots need rebuilding when dependencies change.
It also covers only half the list. The builds are isolated now, but the agents still aren't.
That's why I still think fully hosted is the ideal. A fresh machine per task covers the whole list, agent included.
This is what would get me to move back:
- Every subscription I pay for, working through my own proxy.
- Parts of the environment I can swap out or adjust.
- An MCP as good as T3 Code's.
- Subagents from other model families that are as easy to call.
Amp is moving fast. In October it added Claude plan support and self-hosted orbs. This list may be shorter by the time you read it.
Until then my agents stay home, and their builds run in the cloud.