ThedurableruntimeforproductionAIagents.
Give each agent a persistent Linux workspace in one API call — filesystem, headless browser, shell, HTTP, persistent memory, and a signed identity, pre-wired. If a run is interrupted, the agent restarts and resumes from the last completed step. Bring your own model key.
THE PROBLEM
Agents demo well. Then they hit production.
A stateless runtime is fine in a demo — until real traffic shows up. The host restarts mid-task, the workspace is wiped, and the agent loses its place: it re-runs expensive steps it already finished, or dies halfway through. What breaks long-running agents in production usually isn't the model — it's a runtime that forgets everything the moment something goes wrong. Building the persistence, sandboxing, retries, and recovery to fix that is months of infrastructure work most teams don't want to own.
HOW IT WORKS
Give your agent a persistent computer in one call.
No Dockerfile, no Kubernetes, no checkpointing code to build and babysit.
Spawn in one call
One API call returns a persistent Linux workspace — 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.
Interrupted? It resumes.
If the process or the host restarts mid-task, the agent 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 killed the process mid-task. It resumed and finished.
Verified end-to-end on real hardware: an agent wrote to memory, had its process killed mid-task, 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.
AGENT WORKSPACE
A durable computer for every production agent.
Files, browser, shell, HTTP, memory, and signed identity arrive as one persistent runtime. Your agent keeps its place when the process does not.
agent_8f42 workspace
Persistent runtime · resume-safe execution
Runtime surface
/workspace
Persistent volume
Progress files, downloads, browser state, and outputs survive a restart.
browser
Chromium included
Navigate, click, scrape, and fill forms with Playwright.
shell
Real commands
Install packages, run scripts, and inspect the environment while isolated.
memory
State across runs
Keep facts and context available to the same agent after it resumes.
Durability loop
- 01
Spawn workspace
doneLinux filesystem, browser, shell, HTTP, memory, and identity are ready.
- 02
Checkpoint each step
doneCompleted work is recorded so a restart does not repeat expensive actions.
- 03
Resume safely
doneThe agent continues from the last completed step with its workspace intact.
0
steps repeated after restart
ES256
signed agent identity
BYOK
model key stays yours
Filesystem
A persistent /workspace. Files persist across restarts 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. Memory survives a restart 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 for state to matter.
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. An interruption 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 runtime that survives restarts.
Spawn an agent on a persistent runtime in one API call — it survives restarts and resumes where it left off. Free to start, no credit card.