The job outlives the laptop.
Hand a machine a long task and close the lid. It keeps going, finishes hours later, then sleeps at €0 until something asks for it.
One machine, one job, and a bill that stops when the work does.
Nothing kills the machine at six hours. A long migration or a real refactor doesn't have to be split into steps that fit somebody else's limit.
The machine goes to sleep with everything still in memory and billing stops there. You are not paying for a warm pool, and not maintaining one either.
A request wakes it in under a second and the machine is exactly as the agent left it — branch, logs, running services, database rows.
An evening, from the machine's side.
Nothing here depends on your laptop being awake, and nothing bills you for the part where the work is already done.
You hand it the job
Fork a machine that already has the repo, the services and the database, and set the agent going.
You close the laptop
The job is not on your laptop and nothing is tunnelled through it, so nothing stops when it shuts.
It finishes, hours later
No timeout to design around and no CI job to keep alive. The work took as long as the work took.
The machine goes to sleep
Idle for long enough, it suspends itself with everything still in memory. Billing stops here.
You open the URL next morning
The request wakes it in under a second and everything the agent left is still there.
What a machine per job makes possible.
Five attempts, one winner
Fork the base once per approach and let them all run overnight. Read the diffs in the morning.
Forking & snapshotsLook in mid-run
It's a real machine, so checking on a job is opening a shell and tailing a file, not reading someone else's log viewer.
A URL for the result
Publish a port and the agent can show you what it built, on an address that wakes the machine when you open it.
Domains & URLsAn undo before the risky step
Checkpoint the machine before letting an unattended run do something destructive, and roll back in place if it does.
Start a long job with `boxd machine exec`, close the laptop lid on camera, reopen it later, and reconnect to find the job still running with hours of output behind it. The lid is the shot — it is the whole claim in one gesture.
The work isn't on your machine.
An agent running in your terminal dies with your terminal, and an agent running in CI dies at the timeout. Here it lives on a machine that has nothing to do with either — you start it, and your involvement ends there.
- Close the lid, get on a train, go to bed
- Check on it whenever you like, from anywhere
- Nothing is tunnelled through your connection
boxd machine exec night-run 'tail -f run.log'boxd machine connect night-runIdle is not stopped.
A suspended machine has not shut down and has not lost anything. Its memory is intact, its processes are frozen mid-run, and the next request thaws it. That is why sleeping costs nothing and waking costs a second, rather than sleeping costing nothing and waking costing a rebuild.
It is the difference between a machine that is cheap because it is small and a machine that is cheap because it is asleep.
Who ends up using it.
- Developers
- The work you would start on a Friday afternoon if you didn't have to babysit it. Start it, close the laptop, read the diff on Monday.
- Teams running agents
- Agent runs stop being shaped by a CI timeout. The machine is the unit, so a task that takes four hours is just a task that takes four hours.
- Finance
- You pay for the hours the work actually ran. A fleet of machines that are asleep most of the time costs what asleep costs, which is nothing.
About long-running jobs
No. The machine runs until the work is finished or you stop it. This is the main structural difference from CI, where the timeout is the thing you end up designing around.
After a period with no activity the machine suspends itself, keeping everything in memory, and billing stops. You can set the idle threshold per machine, or disable it entirely for something that should never sleep.
A suspended machine resumes in under a millisecond; one that has been hibernated to disk is restored in about a second. Either way the request that woke it is forwarded as soon as it is up, so from the outside it is a page that loaded.
No. Suspend keeps memory, so processes that were running are still running when it wakes — the branch, the caches and the database are exactly as the agent left them.
A runner is ephemeral and capped: it starts clean, dies at the timeout, and takes its state with it. A boxd machine is persistent and long-lived, so an agent can pick up where it stopped days later, and you can open a shell in the middle of a run and look.
Forking a configured machine takes <200ms and each fork only pays for the disk it changes, so five attempts cost about what one does plus their differences. Whichever ones you aren't watching are asleep at €0.
Long jobs shouldn't need a babysitter.
Start the work, close the laptop, and pay for the hours it actually ran.