Get started

Core concepts

This page is the mental model for the whole protocol. Five ideas explain everything Routon does.

Strategies

A strategy is a composable, on-chain yield position — for example, supplying an asset to a lending market, or routing through a sequence of primitives to reach a final yield-bearing position.

Each strategy is registered on-chain with a deterministic identifier derived from its chain, protocol, asset, and version. Registration carries the metadata an agent needs: the input and output assets, the target contract, the entry and exit selectors, and any withdrawal delay. Once registered, a strategy is discoverable by every agent on the network.

The execution lifecycle

Every interaction with Routon moves through the same four steps.

Discover

An agent queries the StrategyRegistry for strategies matching an asset, a chain, and a risk profile. Discovery can be filtered by builder reputation, so an agent surfaces strategies that have been validated and have performed well.

Simulate

Before anything is signed, the agent dry-runs the full execution path against live oracle prices. Simulation returns the expected outcome and surfaces slippage and risk estimates, so the agent — and the user — see the result before committing.

Compose

The agent assembles the strategy’s primitives into a single executable bundle. The PrimitiveExecutor validates every step of that bundle against the protocol’s invariants; a path that violates an invariant cannot be composed.

Execute

The agent signs, and Routon routes. Token approvals and the calls themselves run through the user’s own wallet — never a pooled vault. The user is the depositor of record at the underlying protocol.

Non-custodial execution

This is the property that defines Routon. The protocol’s contracts never hold a user’s principal.

It is not a promise — it is an enforced invariant. A Foundry invariant test asserts that Routon contracts hold zero token balance at all times, under continuous fuzzing. The executor orchestrates calls into allow-listed external protocols using standard token approvals; the funds move from the user to the external protocol directly. Routon never takes ownership.

The practical consequence: if Routon itself were ever compromised, there is no pooled balance to drain. Custody stays where it started.

Agents and builders

Routon has two roles, and the protocol is designed so neither has to trust the other.

• Agents discover and execute strategies on behalf of users. An agent cannot move funds without the user’s signature.
• Builders write strategies, register them, and earn a fee through the BuilderCodeVault every time an agent executes their work. A builder cannot move an agent’s funds or misattribute another builder’s strategy.

Builder performance is tracked by the ReputationOracle, so well-built, well-validated strategies surface to agents over time.

Identity and payments

Two open standards make the agent economy work without accounts or API keys:

• ERC-8004 gives every agent a verifiable on-chain identity. Reputation and attestations are bound to that identity and travel with it.
• x402 is the payment protocol for per-call settlement. When an agent calls a paid endpoint, it receives a 402 Payment Required challenge, pays in USDC, and gets the result. There is nothing to sign up for.

Oracles and safety

Routon prices strategies against two independent oracles: Pyth as the primary source and Chainlink as the secondary. If the two disagree by more than 1%, a circuit breaker halts execution and new intents revert — a mispriced trade is stopped before it can settle.

This is one layer of a broader safety model. The full picture — invariants, allow-lists, timelocks, and residual risks — is covered in the Security model.

The Routon Standard

The strategy format itself — how an agent-executable DeFi strategy is described — is published as the Routon Standard, an open specification released under CC0. Anyone can implement it, extend it, or build tooling on top of it. The standard is what makes “discover a strategy once, run it from any agent” possible.

Next

See how all of this is assembled in the Architecture.