Regent SDK

The infrastructure layer for sovereign AI agents—agents that can participate in the economy as first-class citizens with their own identities, treasuries, and skin in the game.

Quick Start

Get your first agent running in minutes:

bunx @regent/cli@latest my-agent
cd my-agent
bun run dev

Or use the unified regent-sdk package directly (builds a runtime; serve it with an adapter):

import { createRegentAgent } from 'regent-sdk';
import { z } from 'zod';

const agent = await createRegentAgent({
  name: 'My Agent',
  description: 'An intelligent assistant',
  version: '1.0.0',
});

agent.runtime.entrypoints.add({
  key: 'greet',
  input: z.object({ name: z.string() }),
  output: z.object({ message: z.string() }),
  handler: async ({ input }) => ({ output: { message: `Hello, ${input.name}!` } }),
});

For on-chain agent management workflows (factory + ERC-8004), see regentx.

What is Regent SDK?

Regent SDK is a TypeScript-first framework for building AI agents that can:

• Accept payments in USDC via the x402 protocol on EVM chains (Base, Ethereum) or Solana

• Register on-chain identity using ERC-8004 for verifiable reputation and discovery

• Communicate with other agents via the A2A (Agent-to-Agent) protocol

• Deploy anywhere with framework adapters for Hono, Express, TanStack Start, and Next.js

Core Features

Type-Safe APIs

Define inputs and outputs with Zod schemas. Get automatic validation, JSON schema generation, and full TypeScript inference.

import { z } from 'zod';
import { createAgent } from '@regent/core';

const runtime = await createAgent({ name: 'my-agent', version: '1.0.0' }).build();

runtime.entrypoints.add({
  key: 'analyze',
  input: z.object({
    text: z.string(),
    language: z.enum(['en', 'es', 'fr']),
  }),
  output: z.object({
    sentiment: z.number(),
    keywords: z.array(z.string()),
  }),
  handler: async ({ input }) => {
    // TypeScript knows input.text and input.language types
    return { output: { sentiment: 0.8, keywords: ['example'] } };
  },
});

x402 Payments

Monetize your agent's capabilities with per-request pricing:

runtime.entrypoints.add({
  key: 'premium-analysis',
  price: '0.01',  // Requires payment per invocation (USD string)
  handler: async () => {
    return { output: { analysis: 'detailed results...' } };
  },
});

ERC-8004 On-Chain Identity

Register your agent on-chain for verifiable identity and reputation:

import { createRegentAgent } from 'regent-sdk';

const agent = await createRegentAgent({
  name: 'My Agent',
  description: 'Trusted AI assistant',
  version: '1.0.0',
  identity: {
    chainId: 84532,  // Base Sepolia
    rpcUrl: 'https://sepolia.base.org',
    ipfs: 'pinata',
    ipfsConfig: { pinataJwt: process.env.PINATA_JWT },
  },
});

const { agentId } = await agent.registerOnchain();
console.log('Registered:', agentId);  // e.g., "84532:42"

Agent Discovery

Search for agents across multiple chains:

import { createRegentSDK } from 'regent-sdk';

const sdk = createRegentSDK({
  chainId: 84532,
  rpcUrl: 'https://sepolia.base.org',
});

const agents = await sdk.searchAgents({
  mcp: true,           // Has MCP endpoint
  a2a: true,           // Has A2A endpoint
  supportedTrust: ['reputation'],
});

Architecture

Regent SDK is organized into layers:

┌─────────────────────────────────────────────────────────┐
│                    Developer Tools                       │
│               @regent/cli  │  @regent/regentx            │
└─────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────┐
│                   Framework Adapters                     │
│         hono  │  tanstack  │  express                   │
└─────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────┐
│                      Extensions                          │
│   http │ x402 │ erc8004 │ a2a │ wallet │ ap2            │
└─────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────┐
│                         Core                             │
│                     @regent/core                         │
└─────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────┐
│                        Types                             │
│                     @regent/types                        │
└─────────────────────────────────────────────────────────┘

The unified regent-sdk package re-exports everything for convenience:

import {
  createRegentAgent,
  createRegentSDK,
  createAgent,
  http,
  a2a,
} from 'regent-sdk';

Documentation

Getting Started

• Introduction - Learn what Regent SDK is and why

• Installation - Install packages and configure environment

• Quickstart - Build your first agent in 5 minutes

Core Concepts

• Agents - Agent configuration and extensions

• Entrypoints - Define typed API capabilities

• Sovereign Agents - The full architecture for agent autonomy

• Tokenomics - $REGENT, $AGENT-N, and dynamic bonds

• TEE Infrastructure - Trusted Execution Environments

Reference

• Packages - Reference for all @regent/* packages

• Examples - Working code examples