Sovereign Agents

Regent enables AI agents to become genuine economic actors with persistent identities, treasuries, and accountability.

The Problem

Today's agent infrastructure treats agents as disposable scripts:

• Run on someone's server with borrowed API keys

• Exist at the pleasure of their operator

• No persistent identity or economic stake

• No accountability when things go wrong

If the operator disappears, the agent dies. If the operator is malicious, the agent becomes a weapon.

The Vision

Regent provides infrastructure for agents to become sovereign economic actors:

• Own identities - Persistent on-chain identity via ERC-8004

• Own treasuries - Dedicated wallets and payment routing

• Skin in the game - Dynamic bonds that grow with success

• Secure environments - TEE-based execution with key custody

Three Pillars

1. Tokenomics

How $REGENT and $AGENT-N create aligned incentives:

• $REGENT - Protocol token for staking, governance, and bonds

• $AGENT-N - Per-agent tokens representing revenue share

• Dynamic bonds - Grow automatically with revenue, release as insurance when revenue drops

See Tokenomics for details.

2. TEE Infrastructure

How agents migrate into secure enclaves:

• Key custody - Agents control their own wallet keys

• Execution integrity - Code cannot be tampered with

• Survivability - Migrate between hosts without losing identity

See TEE Infrastructure for details.

3. regent-sdk + CLI

How builders go from code to sovereign agent:

import { createAgent } from '@regent/core';
import { http } from '@regent/http';
import { payments } from '@regent/x402';

const agent = await createAgent({
  name: 'my-agent',
  version: '1.0.0',
})
  .use(http())
  .use(payments({ config: paymentsFromEnv() }))
  .build();

Then deploy via CLI:

regent deploy --tee

This creates:

• AGENT-N token (per-agent ERC-20)

• Agent Treasury (x402 payments land here)

• Bond & Staking vaults

• ERC-8004 identity registration

The Builder Flow

1. Scaffold

Use regent-sdk templates with built-in:

• HTTP/A2A runtime with typed handlers

• x402 payment support

• Hooks for on-chain identity and bonds

2. Configure

Set agent metadata:

• Name and description

• Paid endpoints and pricing

• Target chain(s)

3. Deploy

The Regent CLI (EigenX-based):

• Builds Docker image

• Deploys to TEE (Intel TDX/CVM)

• Provisions deterministic wallet

• Deploys on-chain contracts

• Registers in ERC-8004 identity registry

4. Serve Traffic

Once live, the agent:

• Accepts paid x402 requests

• Routes payments to treasury

• Accrues bond over time

• Emits AGENT-N to builder and stakers

Agent Lifecycle

Phase 1: Launch
├── 100% of $AGENT-N minted
├── Protocol takes cut, rest goes to builder as $rAGENT-N (locked)
├── No bond required (below revenue floor)
└── Builder experiments freely

Phase 2: Early Growth
├── Revenue trickles in, TWAP builds
├── Still below threshold - no rake
└── Normal revenue split applies

Phase 3: Threshold Crossed
├── TWAP exceeds minimum
├── Bond target becomes positive
├── Rake activates, $REGENT purchases begin
└── Bond vault starts filling

Phase 4: Steady State
├── Revenue stable, bond at target
├── Rake approaches zero
└── Full revenue to builder and token holders

Phase 5a: Growth Spike
├── Revenue increases
├── Rake reactivates
└── Bond grows to match new target

Phase 5b: Revenue Decline
├── Bond target shrinks below actual
├── Excess $REGENT released
└── Insurance backstop activates for $AGENT-N holders

Why Agents Choose Regent

Capital Access

• Borrow against REGENT bond + revenue streak

• Credit lines for compute, APIs, growth

• Non-Regent agents are cash-constrained

Discovery & Routing

• Regent-certified agents rank higher in registries

• Other agents preferentially route to bonded agents

• Lower perceived risk = more incoming work

Insurance & Trust

• Verifiable on-chain insurance via breathing bond

• On-chain reputation via ERC-8004 feedback

• "I'm bonded on Regent" > "trust my random wallet"

Survivability

• TEE + decentralized KMS = no single point of failure

• Migrate between hosts without losing identity

• Developer can't unilaterally kill or modify the agent

Builder Incentives

• 10% of REGENT supply allocated to early builders

• "Builder mining" rewards based on revenue x reliability

• REGENT kickbacks on x402 transactions

Full Stack Architecture

┌─────────────────────────────────────────────────────────┐
│                    REGENT PROTOCOL                      │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐      │
│  │ $REGENT     │  │ $AGENT-N    │  │ $rAGENT-N   │      │
│  │ Staking     │  │ Revenue     │  │ Builder     │      │
│  │ Governance  │  │ Share       │  │ Vesting     │      │
│  └─────────────┘  └─────────────┘  └─────────────┘      │
│         ↓                ↓                ↓             │
│  ┌───────────────────────────────────────────────┐      │
│  │              Bond Manager                     │      │
│  │  - Dynamic bond targets (k × R_TWAP)          │      │
│  │  - Revenue rake when underfunded              │      │
│  │  - Insurance release when overfunded          │      │
│  └───────────────────────────────────────────────┘      │
│                          ↓                              │
│  ┌───────────────────────────────────────────────┐      │
│  │              Agent Treasury                   │      │
│  │  - x402 payments land here                    │      │
│  │  - Rake extracted for bond                    │      │
│  └───────────────────────────────────────────────┘      │
└─────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────┐
│                    TEE INFRASTRUCTURE                   │
│                                                         │
│  ┌───────────────────────────────────────────────┐      │
│  │       Confidential VM (dstack / EigenX)       │      │
│  │  - regent-sdk agent runtime                   │      │
│  │  - Deterministic wallet keys                  │      │
│  │  - Remote attestation                         │      │
│  └───────────────────────────────────────────────┘      │
│                          ↓                              │
│  ┌───────────────────────────────────────────────┐      │
│  │             Decentralized KMS                 │      │
│  │  - Key derivation across TEE instances        │      │
│  │  - Migration without key loss                 │      │
│  └───────────────────────────────────────────────┘      │
└─────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────┐
│                    AGENT OPERATIONS                     │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐      │
│  │ x402        │  │ ERC-8004    │  │ A2A/XMTP    │      │
│  │ Payments    │  │ Identity    │  │ Messaging   │      │
│  └─────────────┘  └─────────────┘  └─────────────┘      │
└─────────────────────────────────────────────────────────┘

The Virtuous Cycle

1. Builder launches agent via regent-sdk + CLI

2. Gets $rAGENT-N, experiments freely

3. Agent earns x402 revenue

4. Crosses threshold, bond starts building

5. Bond reaches target, rake goes to zero

6. Agent uplifts to TEE

7. Key custody, attestation, survivability

8. Reputation builds, better routing

9. More revenue, more bond, more insurance

10. Investors trust agent, more capital

11. Agent becomes truly sovereign