Protocol
Architecture
Routon is a layered system. On-chain contracts hold the authoritative state and run execution; an off-chain brain provides the intelligence; a distribution layer meets agents where they run. This page walks through each layer.
System layers
| Layer | Responsibility |
|---|---|
| Client | Originates intents — a Telegram bot, an ElizaOS plugin, a custom agent. |
| Distribution | The SDK, CLI, and MCP server. Format-converts intents, handles x402 payments, returns calldata. |
| Edge | The HTTP boundary — authentication, rate limiting, and tracing. |
| Brain | Off-chain intelligence: discovery, risk scoring, composition, and routing. |
| Data | Indexed on-chain reads plus price and risk feeds. |
| Contracts | The on-chain authority for protocol state and execution. |
| External | The audited protocols where user funds actually live. |
Each layer has a single job, and only the contract and external layers are authoritative for funds.
The six core contracts
Routon’s on-chain logic is six small, focused contracts, deployed identically across every supported chain.
| Contract | Role |
|---|---|
StrategyRegistry | Strategy discovery and on-chain identity. Holds the registered strategy metadata an agent reads. |
ValidationRegistry | Pre-flight validation. Stores signed attestations about a strategy’s risk and integrity. |
ReputationOracle | Attested performance. Tracks builder and strategy reputation over time. |
PrimitiveExecutor | Validated step execution. The single contract that calls into external protocols. |
BuilderCodeVault | Builder fee accrual. Records attribution and accrues rebates to registered builders. |
FeeCollector | Transparent settlement. Harvests performance fees and splits builder rebates on-chain. |
PrimitiveExecutor is the most critical contract — it is the only one that interacts with external protocols, and the non-custodial invariant is enforced there. It carries the deepest test coverage, including invariant fuzzing.
The off-chain brain
The intelligence that an agent relies on lives off-chain, in a stateless service composed of four engines:
- Strategy Discoverer — finds candidate strategies from indexed on-chain data.
- Risk Scorer — scores strategies against live Pyth and Chainlink price data across a set of weighted risk factors.
- Composition Engine — assembles primitives into a validated, executable path.
- Execution Router — encodes the final calldata bundle the agent will sign.
The brain is stateless across requests: it holds no authoritative state. Everything that matters lives on-chain, or in a cache that can be rebuilt from on-chain reads.
How funds flow
This is the heart of the non-custodial design.
User wallet → (signs) → PrimitiveExecutor → External protocol (Aave / Morpho / …)
user is the depositor of recordThe agent constructs a calldata bundle and the user signs it. PrimitiveExecutor validates that bundle — checking the registry, the attestation freshness, and the allow-list — and then executes it as calls into allow-listed external protocols, using standard ERC-20 approvals for token movement.
The funds move from the user’s wallet to the external protocol directly. Routon’s contracts orchestrate the call; they never take ownership of the tokens. The user remains the owner of record at the underlying protocol.
Composition over wrapping
Routon does not re-implement lending or trading. It composes existing, independently audited protocols — Aave, Morpho, Uniswap, CoW, and cross-chain routing — through an explicit allow-list. A protocol is only routable if it has been added to that allow-list, and allow-list changes are governed (see the Security model).
This keeps Routon’s own contract surface small and auditable, and it means user positions are held in protocols that have already earned the market’s trust.
Multichain
Routon runs across six chains — Base, Arbitrum, Ethereum, Optimism, Berachain, and Solana. The deployments are functionally identical: the same six-contract design, the same non-custodial guarantees, the same standard.
What differs per chain is local: the allow-listed external protocol addresses, and the indexer for that chain’s strategies. An agent writes against one protocol and reaches all six.
Open standards
Routon is built on open standards rather than proprietary interfaces:
- ERC-8004 for agent identity.
- EIP-712 for signed attestations.
- The Routon Standard — the CC0 specification for agent-executable strategies.
The contracts and SDKs are MIT-licensed. The protocol is designed to be built on, not walled off.
Next
Continue to the Security model for the full trust model, invariants, and residual risks.