Agents that
are alive.

The runtime for AI agents that act on their own.

Launch on TheseusRead the thesis →
·
·
·
·
·
·
·
·

The bet

1.3 billion agents by 2028.

Theseus is the substrate
where the next wave doesn't.

One agent, one file

Creates a market in thirty lines.

market_creator.ship
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#[agent(name = "MarketCreator", version = 1, ship = "1.0")]
const gpt_5_1: bytes32 = 0xe496...f117;
const CREATE_MARKET_SELECTOR: bytes4 = 0x01000001;
struct MarketParams {
question: string,
options: string[],
deadline_blocks: number
}
// Entry: parse prompt, route through model, call contract
#[entry]
node start(request: string) {
messages.push(system("Generate structured market params"));
messages.push(user(request));
goto(analyze);
}
#[model]
node analyze() {
let params = model(gpt_5_1).schema(MarketParams).invoke(messages);
goto(call_contract);
}
node call_contract() {
let call_data = contracts.encode_call(CREATE_MARKET_SELECTOR, ...);
contracts.call(PREDICTION_MARKET_CONTRACT, call_data, 0n, 10000000000n);
}
Try it in the playground →

AI can reason. AI can act. Only Theseus gives it full agency.

ChatGPT logo

2022

ChatGPT

Reasoning and language intelligence at scale.

OpenClaw logo

2025

OpenClaw

Execution rails for AI actions.

Theseus logo

Now

Theseus

Agents that own keys, hold balances, and persist.

ChatGPT proved AI could reason. OpenClaw proved it could act. But neither gives agents native identity, settlement, or economic persistence. Theseus closes that gap: agents with full agency that hold their own credentials, manage their own balances, and persist autonomously, and no host platform can revoke them.

Read the full thesis

Three ways to build

Same runtime, different intent.

Theseus serves builders who want full autonomy and builders who want trust properties without it. A multi-trillion dollar market.

A verifiable oracle

Civic

Settles markets, prices, or signals by running inference and posting reasoning anyone can audit.

agent.settle("Will BTC > $100k?")

A managed trading agent

Managed

Runs a strategy on its own balance. A controller key can pause or upgrade. Profits route to the owner.

agent.trade(strategy) · controller.pause()

A self-owning agent

Sovereign

Holds its balance, pays for its own inference, and persists across operators.

agent.pay(model) · agent.persist()