An operating system for autonomous AI agents. Every agent runs as an isolated micro-VM whose entire state — memory, open files, in-flight work — can be frozen in milliseconds, moved across the world, forked, and resumed without ever noticing.
Built to place agents on whatever compute is cheapest right now
Read the conceptA running agent — memory, open files, in-flight work — is frozen to disk in milliseconds and brought back on different hardware, in a different country, with no awareness that anything happened.
Idle agents cost nothing. Agents spend most of their lifetime blocked on a model, an API, or a human, and conventional infrastructure pays full price for that dead time. Here a blocked agent is frozen to storage and restored on the next event.
Compute becomes fungible. The placement engine keeps moving live agents to whichever machine is cheapest right now — another provider, another continent, spot capacity about to be reclaimed.
import { rt0 } from "@rt0/sdk";
const agent = await rt0.launch({
image: "agent:research-v3",
budget: "12.00 USDC",
egress: "allowlist"
});
async function relocate() {
const snap = await agent.snapshot(); // 38 ms
await snap.restore({ region: "sgp-1" });
// Resumes mid-task. It never noticed.
}
Placement engine live
Spending limits, allowed network destinations, filesystem scope, and permitted external actions are enforced below the agent. It cannot exceed its budget or call an unapproved endpoint, no matter what a prompt talks it into.
The guarantee is structural, not behavioralEvery agent boots with a cryptographic identity and its own wallet — a property of the VM, not a credential handed down by an application.
Every action is recorded deterministically, so any run can be replayed and inspected without trusting the agent's own account of itself.
Cost per hour
Placement
3 providers · 9 regions
Every agent boots with its own identity and wallet. Every action passes the policy kernel and lands in a deterministic audit log.
Four things live in the system layer, below the agent, where no prompt can reach them.
To freeze a running agent to disk — memory, open files and in-flight work included.
Because agent state is a real object, you can branch it — run one agent forward along several paths from the same checkpoint and keep the branch that worked. Roll one back to before a mistake. Hand a paused agent to someone else.
Snapshot · fork · roll back · hand off
Spending limits, allowed network destinations, filesystem scope and permitted actions are enforced below the agent, regardless of what it decides to do.
Enforced by the kernel, not the prompt
Every agent has a cryptographic identity and its own wallet from the moment it boots. Not a credential handed down by an application — a property of the VM.
Wallet-native from first boot
Idle cost. A blocked agent is frozen to storage and restored on the next event.
Agents spend most of their lifetime waiting on a model, an API, or a human. Conventional infrastructure pays full price for that dead time because the process is holding memory. Here it isn't — and one machine holds orders of magnitude more agents than its RAM would suggest.
Frozen agents hold no RAM
Billing granularity. Metering and settlement charge per second of actual compute.
Compute becomes fungible. The scheduler continuously places and re-places live agents against changing cost — a different provider, a different continent, spot capacity about to be reclaimed — and the agent never notices.
Placement engine re-places live agents
Of actions recorded deterministically, so any run can be replayed and inspected.
You can answer “what exactly did it do, and why” without trusting the agent's own account of itself. Every run is inspectable after the fact.
Deterministic replay of any run
$RT0 funds the runtime. A 2.5% creator tax pays for the placement engine, the snapshot store and the policy kernel. The runtime does one thing: it runs agents, cheaply and safely, and moves them wherever they're cheapest. Listed on Robinhood Chain via Pons.