The sandbox is a machine you drive. The agents platform is the layer above it where you define an agent once, and the platform runs it for you — provisioning the machine, starting the process, restarting it when it dies, capturing what it did, and tearing it down when it is finished.
This document describes the design. It is not a feature that exists today; the roadmap says plainly which parts are which.
The problem it solves
Today the lifecycle of an agent is your problem. You SSH into a machine, you start a process, and from then on you own the failure modes:
- When the process dies at 3am, nothing restarts it.
- When you close your laptop, nothing is watching.
- The output is in a scrollback buffer you have to remember to collect.
- You cannot tell how many of your agents are running, or which ones are wedged.
None of that is hard to fix individually and all of it is tedious to fix repeatedly. The agents platform takes ownership of the lifecycle so that you can spend your attention on what the agent should do.
What you define
An agent is a small, declarative thing. The parts we are designing:
| Part | What it is |
|---|---|
| Model | Which model the agent talks to, and with what parameters. |
| Instructions | The system prompt and any task-specific context. |
| Tools | What the agent is allowed to call — shell commands, HTTP endpoints, or other agents. |
| Environment | The image the sandbox is built from, its disk size, and its network policy. |
| Resources | CPU, memory, and how long it may run before it is reclaimed. |
| Trigger | On demand, on a schedule, or when an event arrives. |
| Memory | Whether the agent runs with a private memory, a shared one, or none. |
The point of keeping it declarative is that an agent becomes something you can review, diff, and put in version control — rather than a shell session somebody left running.
What the platform does
Once you define an agent, the platform does the following, and the design is that you can watch every step of it:
- Provisions a sandbox from the image you named, with the resources you asked for.
- Starts the agent with your instructions, your tools, and your environment.
- Keeps it running. If the process exits and the task is not finished, the platform restarts it. The restart policy is part of the definition.
- Captures the output — stdout and stderr, timestamped, and readable as a stream while it runs and as a log after it stops.
- Stops and reclaims it when the task completes, when it fails for good, or when it has been idle past its window.
Everything it does happens inside a sandbox, with the same isolation boundary as the sandbox you drive yourself. The agent does not get a privileged path into the platform, and the platform does not get a view into the agent’s filesystem that you did not give it.
You still get the shell
This is the constraint we are least willing to give up.
An agent running on the platform runs in a sandbox, and you can open a shell in that sandbox exactly as you can with one you created yourself. When an agent does something surprising, you can look at the files it wrote, the process it left behind, and the state of the machine it was running on.
An opaque agent runner is a debugging problem. A sandbox you can walk into is not.
Several agents, several sandboxes
Each agent runs in its own sandbox by default. Two agents do not share a filesystem and cannot see each other’s processes, for the same reason two people cannot see each other’s memory.
Where agents need to work together, the answer is not a shared sandbox — it is the <a href="/docs/memory/">shared memory layer</a>, which is designed to be the thing they share precisely so that the sandbox does not have to be.
What it is not
- It is not an agent framework. We are not shipping a tool-calling library or an opinionated agent loop. You bring the agent; we run it.
- It is not a model provider. We do not host models, and we do not want you to route your work through ours to use the platform.
- It is not an unattended deployment target for everything. The first version is deliberately narrow: one agent, one sandbox, one owner.
What is still open
We are designing this now, and these are the parts we have not settled:
- How an agent reports progress mid-task, and what a partial result looks like.
- How a scheduled agent handles a run that overlaps the previous one.
- How much of the sandbox’s configuration an agent definition should be allowed to control, given that the sandbox is the security boundary.
- Whether an agent may call another agent, and what that means for isolation.
If you have an opinion on any of those, tell us — the argument is cheaper now than after it is built.
Next: shared memory.