Isolation
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.
T0 runs AI coding agents in isolated Linux sandboxes you drive over an API. Each session keeps its workspace between messages, streams every token and tool call as it happens, and is ready the moment you ask for it.
300 free credits a month (5 h of awake session time). No card. Bring your own model provider key.
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"])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.
You supply your model provider key; T0 sells the runtime. It is encrypted at rest, decrypted only at the moment a container is claimed, injected as an environment variable, and never logged or returned.
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.
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 | 300 (5 h) | 3,600 (60 h) | 18,000 (300 h) |
| Daily capcredits per UTC day | 60 | 600 | 2,400 |
| Concurrent sessions | 1 | 3 | 10 |
| Workspace storagedurable, per account | 2 GB | 25 GB | 100 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 |
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, not the model: isolation, persistence, orchestration and latency are the product. 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.
Yes. T0 is bring-your-own-key: you add your model provider key once in the dashboard and T0 runs the agent with it. We do not resell model tokens, so nothing on your bill is a marked-up token — you pay us for compute time and storage only.
Your provider key is encrypted at rest with AES-256-GCM, decrypted only at the moment a container is claimed, injected as an environment variable inside your sandbox, and never logged, never written to disk and never returned by any endpoint.
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. Because you bring your own key, the tier selects the class of model your key is used against.
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.
After idle_timeout (10 minutes by default) the session moves to sleeping: the container stops, the workspace is kept, and a session.idle event is emitted. Sleeping costs nothing — metering counts awake seconds only.
The next message wakes it. A resume inside the warm window is a container start; a colder resume restores the workspace from object storage first. Files can be downloaded from a sleeping session without waking it.
Create an account, add your provider key, and your first session is running in a minute. The free plan is permanent.
Get your free API key