T0 runs AI coding agents in isolated Linux sandboxes, over one REST API.
Model access included with every plan.
Anyone can call a model. The hard part is giving it somewhere safe to work, keeping that somewhere alive between messages, and doing both fast enough that it feels local. That is the entire product.
Every session is its own container: read-only root filesystem, all capabilities dropped, seccomp, a pids ceiling, hard memory and CPU caps, and default-deny egress through an allowlist proxy that refuses every private network range.
The workspace is a volume, not a scratch directory. Files the agent wrote, packages it installed and git state are all still there on the next message — days later, if you want.
Create, list, interrupt and expire sessions from one API. Run as many in parallel as your plan allows, each with its own workspace, its own environment and its own event stream.
Sessions are claimed from a pool of pre-booted containers, so creating one is bookkeeping rather than a boot. The agent process stays alive between messages, which is the single largest latency win available.
An idle session stops its container and keeps its volume. Resuming is a start, not a rebuild, and sleeping is never metered — a credit is one minute of awake time.
Model access is included: sessions run on T0's own Claude Code account behind T0's gateway — you never handle a model credential, and your plan's credits are the only meter. There is nothing to add and no credential to manage: the account credential never enters your sandbox.
The whole API is sessions, messages, events and files. Everything else is a detail of those four.
One POST. You get an id, a state and a stream URL back, from a container that was already running.
A single PUT for one file, a tar.gz for a whole tree. Everything lands under /workspace.
The prompt is written into the live agent process. Text, tool calls and file changes stream straight back.
Download files, keep the session for the next message, or let it sleep. Sleeping costs nothing.
curl -X POST https://api.t0.sikasio.com/v1/sessions \
-H "Authorization: Bearer t0k_live_YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{
"name": "invoice-parser",
"model": "core",
"idle_timeout": 600,
"ttl": 86400,
"env": { "NODE_ENV": "test" }
}'// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };
const session = await fetch(T0 + "/sessions", {
method: "POST",
headers: { ...auth, "Content-Type": "application/json" },
body: JSON.stringify({
name: "invoice-parser",
model: "core",
idle_timeout: 600,
ttl: 86400,
env: { NODE_ENV: "test" },
}),
}).then((r) => r.json());
console.log(session.id, session.state, session.stream_url);import os, requests
T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}
session = requests.post(
T0 + "/sessions",
headers=auth,
json={
"name": "invoice-parser",
"model": "core",
"idle_timeout": 600,
"ttl": 86400,
"env": {"NODE_ENV": "test"},
},
).json()
print(session["id"], session["state"], session["stream_url"])T0 means time zero: a session is ready the moment it is asked for. These are the targets the system is built to and load-tested against — p95, not best case.
| Path | Target (p95) |
|---|---|
| Key authorization | < 1 ms |
| Session create, warm pool hit | < 300 ms |
| Resume from sleep | < 500 ms |
| Cold resume, workspace restored | < 3 s |
| Gateway overhead on first token | < 50 ms |
| Event delivery jitter | < 20 ms |
A credit is one minute of awake session time. Sleeping costs nothing, and going over a quota is a hard stop with an upgrade prompt rather than a surprise bill.
| Free | Starter | Pro | |
|---|---|---|---|
| Price | $0 | $19/mo | $59/mo |
| Credits / monthone credit = one minute awake | 60 (1 h) | 600 (10 h) | 2,400 (40 h) |
| Daily capcredits per UTC day | 20 | 120 | 360 |
| Concurrent sessions | 1 | 3 | 10 |
| Concurrent runsone-shot /v1/runs, counted apart | 2 | 10 | 30 |
| Workspace storagedurable, per account | 400 MB | 5 GB | 20 GB |
| Live disk per sessiontechnical ceiling | 5 GB | 10 GB | 20 GB |
| Retentionafter a session ends | 7 days | 30 days | 90 days |
| Sandboxmemory / CPU | 1 GB / 1 CPU | 2 GB / 1.5 CPU | 4 GB / 2 CPU |
| Past the allowancecredits, on every plan | $0.04 / min | $0.04 / min | $0.04 / min |
| Top-upscredits never expire | $10 → 250 · $25 → 625 | $10 → 250 · $25 → 625 | $10 → 250 · $25 → 625 |
The rest are answered in the documentation.
T0 sells hosted, sandboxed AI coding-agent sessions over a REST API. You create a session, push files into it, send it messages, and stream the agent working in real time. Each session is an isolated Linux workspace that persists between messages, so files the agent wrote, packages it installed and git state are all still there on the next message.
T0 sells the runtime — isolation, persistence, orchestration and latency — with model access included in every plan. Base URL: https://api.t0.sikasio.com/v1.
Create an account at https://t0.sikasio.com/signup with an email and a password, verify the code we email you, and your key is shown once — copy it straight away. Send it as an Authorization: Bearer header on every /v1 request.
Keys are the tenant boundary: they identify the account, authorize the request, and are what usage is metered against. Revoke one from the dashboard and it stops working within seconds.
No. Model access is included with your plan: sessions run on T0's own Claude Code account behind T0's gateway, so there is nothing to bring, no token to paste and no model credential to manage. The account credential never enters your sandbox, and your plan's credits are the only meter.
Two tiers, named by T0: core for everyday work and max for the hardest tasks. Set the tier when you create a session; core is the default. Model access is included with your plan, so the tier is the only model choice you make.
Yes — POST /v1/runs takes one prompt and returns one answer in the same HTTP call. It creates a session, runs the turn, and hands the container back; you never see the session. Use it for classification, extraction, drafting and summarising, and use a session when the agent needs a workspace, tools or memory of what it just did.
Tools are off by default on a run, which is most of why it is cheap: an agent holding a toolkit spends billable seconds deciding whether to use it on a question that needed none. Send tools: "all" when the work genuinely needs the machine.
Ask for JSON with response_format — either json_object, or json_schema with a schema — and the answer comes back parsed in output_json. An answer that does not match is sent back once for repair before the call fails.
Runs are counted against their own concurrency ceiling rather than against concurrent sessions, so a burst of one-shot calls never locks you out of the sandboxes you are keeping open.
Everything inside /workspace, plus the agent process itself. The process stays alive for the life of the session, so conversation context stays resident and follow-up turns do not re-read everything from scratch. That is the single largest latency win in the system.
When a session goes idle the container stops but its volume survives, so resuming is a start rather than a rebuild. Workspaces are also snapshotted to object storage, which is what makes a resume possible days later.
Create an account and your first session is running in a minute — model access is included. The free plan is permanent.
Get your free API key