Thesandboxyouragentneverloses.
Crash, restart, and pick up exactly where it left off — with memory intact. Spawn a sandboxed Linux agent in one API call: filesystem, headless browser, shell, HTTP, persistent memory, and a signed identity, all pre-wired. Bring your own model key.
THE PROBLEM
Agents demo beautifully. Then they hit production.
A stateless sandbox looks brilliant — until real traffic shows up. The host restarts mid-task, the box is wiped, and the agent loses its place. It re-runs expensive steps it already finished, or simply dies halfway through. What breaks long-running agents in production usually isn't the model. It's the infrastructure forgetting everything the moment something goes wrong.
| Most sandboxes | Jettson |
|---|---|
| When the host crashesThe agent loses its context and starts the task over | Auto-restarts and resumes from the last completed step |
| Work already doneRe-runs steps it already finished | Skips finished steps — no repeated work |
| The workspaceWiped when the box dies, then purged on a timer | Persists on a volume until you delete it |
| Memory across runsBolt it on yourself — or there isn't any | Persistent memory, built in |
| Crash recoveryDIY checkpointing you have to build and maintain | Built in — state is checkpointed after every step |
HOW IT WORKS
Spawn a crash-proof agent in one call.
No Dockerfile, no Kubernetes, no checkpointing code to build and babysit.
Spawn in one call
One API call returns a sandboxed Linux agent — filesystem, headless browser, shell, HTTP, persistent memory, and a signed identity, already wired. Bring your own model key.
It runs — and remembers
Your agent works on a real machine with memory that persists across runs and a signed identity, so every action it takes is attributable and auditable.
It crashes? It resumes.
If the process or the host dies mid-task, the agent auto-restarts and picks up from the last completed step — finished work isn't repeated.
import { Jettson } from "@jettson/sdk"; const jettson = new Jettson({ apiKey: process.env.JETTSON_API_KEY }); // One call → a Linux box with memory, browser, shell + a signed identity.const agent = await jettson.agents.spawn({ task: "Research 10 vendors and email the top 3",}); // If the host crashes mid-task, it auto-resumes from the last step.const result = await jettson.agents.wait(agent.agent_id);console.log(result.final_result);SEE IT RESUME
We hard-killed it mid-task. It finished anyway.
Proven end-to-end on real hardware: an agent wrote to memory, got hard-killed mid-task, auto-restarted with no human in the loop, resumed from the last completed step, and read its memory back out — without repeating completed work.
Illustrative replay of the exact event sequence we verified on real hardware.
BATTERIES INCLUDED
Everything a long-running agent needs, pre-wired.
One API call gives your agent a real computer — plus the two things that make it survivable and trustworthy.
Filesystem
A persistent /workspace. Files survive a crash and are still there when the agent resumes.
Headless browser
Chromium via Playwright — navigate, click, scrape, and fill forms.
Shell
Run real commands, install packages, and execute code in an isolated box.
HTTP
Outbound requests with SSRF protection — call whatever API the task needs.
Persistent memory
Agents remember across runs — facts, preferences, and context persist. It survives a crash too, so a resumed agent still knows what it learned.
Signed identity + audit trail
Every agent carries a signed identity (ES256), and every action it takes is logged. Together that's a replayable audit trail — who the agent was and exactly what it did. The trust layer regulated teams need before they deploy.
WHO IT'S FOR
Built for agents that run long enough to crash.
If your agent finishes in two seconds, you don't need us. If it runs for minutes, hours, or overnight — across many steps — losing state isn't an annoyance. It's a re-run and a double bill.
Just firing a single quick call? A plain stateless sandbox is fine — and cheaper. Jettson earns its keep when your agent runs long enough that losing state actually hurts.
Overnight & long-running jobs
Agents that work for minutes to hours. A crash at hour two shouldn't throw the whole job away and start over.
Multi-step workflows
Research → scrape → draft → send. Every step costs tokens and time — none of them should run twice.
Stateful, memory-heavy agents
Agents that build up context as they go and can't afford to forget it the moment the host restarts.
Teams priced out of enterprise
You shouldn't need a $3,000-a-month enterprise minimum to get durable agents. Start on a $9 plan.
START FREE
Give your agent a sandbox it never loses.
Spawn a crash-proof agent in one API call — it survives crashes and resumes where it left off. Free to start, no credit card.