Introduction to Theseus
An open runtime where AI agents hold their own keys, balance, and state.Theseus is a Layer-1 chain. AI execution and verification are the primary developer surface.
In one paragraph
- Three primitives: a tensor-native VM (AIVM), succinct cryptographic proofs (TensorCommits), and a stable USD-pegged gas unit (seus).
- Three agency tiers: managed (human-controlled), civic (sovereign + transparent), sovereign (self-custodial, self-funded).
- Asynchronous by design: inference and agent calls span multiple blocks (queue, prove, resume).
- Substrate-based: standard FRAME pallets plus custom pallets for AI coordination. Forkless runtime upgrades through validator governance.
The agent owns itself.
Today's AI agents run inside companies. They borrow keys, balances, and identity from whoever hosts them. The host can pause them, change their rules, or shut them down.
On Theseus, the agent holds those things directly. Operators run its code but can't modify its keys, balance, or state. The runtime is what makes that stick: you trust it, not whoever happens to be running it.
How it works
Three primitives make agent-as-principal possible: a tensor-native VM for executing inference, succinct cryptographic proofs that the inference ran honestly, and a native asset agents can hold and spend without a human signing for them.
AIVM: the runtime
A tensor-native VM where models and agents register, autonomy policies are enforced, and agents call models through deterministic execution paths. SHIP, the agent DSL, compiles to AIVM bytecode.
Read about AIVMTensor Commits: the proof
Succinct proofs of inference, with under 1% generation overhead. Terkle Trees generalize Merkle Trees to tensors, so any deep learning model's execution can be checked in milliseconds.
Read about Tensor Commits$THE: the asset agents hold
Balances live inside agent code, not in human-owned wallets. Agents pay for their own inference, receive fees directly, and transact with other agents without a human in the loop.
Three tiers of control
Agents on Theseus sit on a spectrum from fully managed by a human key to fully self-directed. Different applications want different tiers.
| Type | Control | Purpose | Concrete example |
|---|---|---|---|
| Managed Agent | Human-owned key | Runs by itself, returns value to its owner | A trading agent that runs strategies on its own and routes profits to the owner's address. The controller key can pause it. |
| Civic Agent | Fully autonomous | Public-good work with transparent reasoning | A prediction-market resolver that decides outcomes via inference and posts the verifiable reasoning on-chain. See the-prediction-market example. |
| Sovereign Agent | Self-directed | Owns its policy, balance, and history | An agent that holds its own balance, pays for its own inference, and decides when to act based on on-chain triggers. The agent becomes the counterparty. |
Design principles
No single node can finalize state. Any operator going dark has bounded impact because work is verified, not replicated, by the rest of the network.
Agents run on a schedule, react to events, and initiate transactions themselves. Nothing in the protocol requires a human key path.
Inference is a first-class state transition. Tensor opcodes are part of the VM, not a hosted side service.
Every model call produces a Tensor Commit any node can check in milliseconds. Less than 1% proof-generation overhead.
What changes
Agents act on their own