Introducing Hoplite

Sometime in the last year, coding agents quietly crossed a line. Give one a well-scoped task and a working development environment and it will, more often than not, come back with the thing done. Tests written, edge cases handled, the lot. We know because we've been building software this way ourselves, and the bottleneck stopped being the model months ago.

The bottleneck is how we run them. An agent on your laptop shares your checkout, your uncommitted changes, your credentials, your CPU. It occupies your terminal like a houseguest. You can run one at a time, you have to watch it, and when you close the lid the work stops. The model is doing engineering while the human does babysitting, and the babysitting is the part that doesn't scale.

Hoplite is our answer. You describe the work. We run the agent in an isolated cloud sandbox, a real Linux machine with your repository cloned, dependencies installed, and your project's own setup script applied. Then you close the laptop and go do something else. What comes back is a pull request.

Isolation is what makes delegation safe

The reason people hover over agents is that the blast radius is their own machine. Fair enough. On Hoplite, every task gets a machine of its own, born from your repo and destroyed after the run. The agent can install packages, run migrations against a scratch database, or make a mess of the working tree, and none of it can reach you or any other task. Want to try three approaches to the same refactor? That's three separate machines and three pull requests that can't collide with each other.

The sandboxes are fast, too. Warm starts resume in under a second, and cold ones come up with your project already built, because we snapshot the environment after setup rather than rebuilding it every time. The point of delegating is that the work starts now, not after five minutes of npm install.

The pull request is the interface

Early on we made a decision that shaped everything after it: agents propose, people decide. Every thread ends in a reviewable diff with the full transcript attached, so you can see what the agent tried, what the tests said, and where it changed its mind. If the work is good, merge it. If it's close, leave review comments and the agent picks them up. If it's wrong, close it and you've lost nothing but a sandbox.

We built it this way because we don't actually believe in unsupervised code changes, ours or anyone's. Hoplite's job is to make sure that by the time a change needs your judgment, the mechanical work is already done.

What's there today

• Threads: delegate a task, watch it live or don't, get a pull request
• GitHub integration end to end, from repo import to review comments that agents act on
• Parallel work by default, since every task brings its own machine
• A free plan that's genuinely usable, because the way to evaluate this is on your own repo

We're a small team, we use Hoplite to build Hoplite (this website shipped through it), and we're backed by Y Combinator. Connect a repository, hand an agent the ticket you've been putting off, and see what comes back. Worst case, you're out a coffee break.