Start here

Sandbox API

Every call an intentic sandbox answers (363 of them), generated from the wire contract the daemon and its own browser client both import. Each one has a playground on its page that answers you back.

On this page(4 sections)

Whose API this is
In one minute
The whole surface
How this is made

Whose API this is

There is no intentic API in the cloud that reaches your code. The platform holds your identity and your sandbox's address and nothing else. Everything documented here is served by your daemon, inside your container, on hardware you own, and the only way in is a credential you minted yourself.

That is also why the playgrounds on these pages answer from a simulation in your own tab rather than by calling anything. There is no shared server to point a demo at, and a demo that needed you to have a sandbox, sign in to it and open its door first would be a demo almost nobody reached. What the playground gives you instead is every one of the 363 calls, including the destructive ones, with the real address, the real fields and the real shapes, and beside each one, the curl that does it for real.

In one minute

The call most people are here for, and the one that shows the API's whole personality: start work, then watch it.

Drive an agent from a script

SANDBOX=https://sandbox-a1b2c3d4e5f6.intentic.dev

# Say something to an agent. It answers as soon as the run exists; the work is detached.
curl -X POST "$SANDBOX/agent" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"prompt":"Update the changelog for the last five commits.",
       "conversationId":"nightly-changelog",
       "isolated":true}'

{ "run": "run_8c2f41d9" }

# Watch it happen, from the start or from wherever you got to.
curl -N -X POST "$SANDBOX/agent/attach" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"conversationId":"nightly-changelog","after":0}'

Starting a turn hands back a run id and nothing else, because the work runs inside the sandbox whether or not you stay connected. Any number of watchers can attach to the same run from any number of devices; a reload loses nothing. Read Authorising a call for where that token comes from, and The shape of a call for the two conventions that cover all 363.

The whole surface

Thirty-seven groups on seven shelves. Nothing below was typed by hand: the groups, their routes and every field in them come from the contract, and only the sentence under each name is written by a person.

Agents

Say something to an agent, watch it work, and decide what happens to what it wrote.

One agent15Run a turn in one conversation, then attach to it, answer it, steer it or stop it The fleet32Every registered conversation, its accumulated diff, and landing or discarding its work Past sessions2Conversations that have finished, and their transcripts Workflows9Several agents in a fixed order, the designs and the runs Loops6One conversation run again until it gets there, and the saved designs behind them Automations11Work the sandbox starts on its own, and the approvals it parks waiting for you

The workspace

The files and repos the agents work on, and the history of both.

Workspace31The file tree the agents work on: read it, search it, change it, and run what is in it Git45Version control, one repository at a time Diffs1Both sides of a changed document as text, for the files a line diff cannot show History4Saved states of the whole workspace, and putting one back Chores3What every repository currently measures, and what has been done about it Panels3Each repository's dev server: what it is and whether it is running Ports3What is listening inside the sandbox, and forwarding one out Areas3The named parts of the workspace a teammate's reach is granted in

Agent setup

The instructions, characters and add-ons that decide how an agent behaves.

Personas8Named characters an agent can wear: the accounts it speaks for and what it is told Skills5The instruction packs an agent can be handed Extensions22Installed extensions: their settings, their readiness, their updates and their processes Settings11The sandbox's own configuration, plus what it has saved you and which rules fired Safety policy3The document deciding when an agent stops to ask, and the record of what it decided Privacy shield8What personal data is kept from model providers, and the record of what was masked

Connected systems

The outside world: accounts, credentials, tunnels and the infrastructure you declared.

Capabilities14The outside systems this sandbox is wired into, and connecting a new one Needs8What an agent asked you to connect or provide before it can go on Secrets12Stored values the agent can use without ever reading them VPN4Corporate tunnels the sandbox can hold open Network disks3Shares on a file server the sandbox can hold mounted Exit locations7Sending the sandbox's outbound traffic out of a chosen country Inventory3What this sandbox has and what it wants, as declared deployment intent Platform CLI3Run the in-sandbox platform tool and follow its output as it arrives

Models and accounts

Which models are available, whose subscription pays for them, and what has been spent.

Accounts7Subscriptions this sandbox holds itself, for any provider, with the provider in the address Routed providers5Subscriptions that run another vendor's model under the Claude Code harness Endpoints4A model server you configured, and the free trial's allowance Providers2A built-in provider's model catalogue Usage4What has been spent, grouped

Ship and share

Checks before code leaves the machine, and the ways work reaches other people.

Pipelines5Continuous integration runs, and asking an agent to fix a failed one Offloaded work5Send heavy commands such as tests and typechecks to a runner on one of your machines Outbox3Files published to a public address, with no sign-in Sharing4Conversations published as read-only pages Approvals6Things the agent has prepared, waiting for you to say yes Issues5Bugs your own users hit, grouped, and putting an agent on one

The sandbox itself

The daemon's own identity, its live event stream, and the record it keeps.

System25The daemon itself: its identity, its event stream, its terminals, its browsers, its helpers Activity2The audit feed of what the agent did out in the world Logs3The sandbox's durable debug record Push notifications4So a finished turn can reach you when the tab is closed

How this is made

The daemon and the app share one typed contract: it declares every route's method, path, input shape and output shape, and both sides import it rather than agreeing to match. These pages are that contract rendered, so they cannot describe a route the daemon does not serve, and a route added to the contract is documented the day it lands.

The same thing is served as a machine-readable document at openapi.json: OpenAPI 3.1, for a client generator, an editor's HTTP plugin, or a model that needs to be told what a sandbox can do.