AgentRails

The orchestration layer between AI agents and the financial system

www.agentrails.io | Documentation | Blog | Microsoft Marketplace

Agent-agnostic. Model-agnostic. Enterprise-ready.

AgentRails connects any AI agent to payment infrastructure with the budget controls, transaction logging, and compliance that businesses demand.

The Problem

As AI agents proliferate, they need to transact. But:

• LLM providers (OpenAI, Anthropic, Google) build models, not payment rails
• Agent frameworks (LangChain, CrewAI, Semantic Kernel) orchestrate reasoning, not money
• Model routers (ClawRouter, etc.) optimize inference costs, not compliance

No one owns the bottleneck between intelligent agents and the financial system.

The Solution

AgentRails is payment orchestration infrastructure for the agentic economy:

What We Do	What We Don't Do
Connect agents to financial rails	Build AI models
Enforce budget policies	Route to different LLMs
Log every transaction	Compete with agent frameworks
Provide audit trails	Lock you into our stack

"The value is not in the application. It is in the connective tissue between applications, data, and decisions."

— Jordi Visser, "Palantir as Signal"

AgentRails is the connective tissue between AI agents and the financial system.

Why This Matters

The Shift: SaaS to Value-Based Pricing

Old Model (SaaS)	New Model (Agentic)
Per-seat pricing	Per-transaction pricing
Humans use software	Agents use APIs
Monthly subscriptions	Micropayments per action
$50/seat/month	$0.001 per API call

AgentRails provides the payment rails for this new model via the x402 protocol.

The Moat: Switching Costs

Once agents are wired to AgentRails:

• Transaction history lives here
• Budget policies are configured here
• Compliance audit trails are here
• Switching means rebuilding all of it

Core Capabilities

Agent-Agnostic Integration

Works with any AI agent, any framework, any model:

• OpenAI GPT-4o, Claude, Gemini, Llama, Mistral
• LangChain, CrewAI, AutoGen, Semantic Kernel
• Custom agents, enterprise agents, open-source agents

Autonomous Commerce

• Research options using built-in knowledge bases
• Make informed decisions via AI reasoning
• Execute USDC payments on Arc blockchain
• Manage budgets with constraint enforcement
• Settle instantly with sub-second finality
• Persist forever with PostgreSQL database

x402 Payment Protocol (V2 Spec-Compliant)

• Pay for APIs using HTTP 402 micropayments
• Monetize your APIs with one line of code
• EIP-3009 signed authorizations (gasless)
• Multi-network support (Arc, Base, Ethereum)

Enterprise Governance

• Budget controls (per-transaction, daily, weekly limits)
• Destination whitelists/blacklists
• Approval workflows for high-value transactions
• Complete audit trail for compliance

How It Works

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Any AI Agent │ │ AgentRails │ │ Financial │
│ │ │ │ │ System │
│ - GPT-4o │────▶│ - Orchestrate │────▶│ │
│ - Claude │ │ - Authorize │ │ - USDC │
│ - Llama │ │ - Log │ │ - Arc/Base │
│ - Custom │ │ - Settle │ │ - Banks (soon) │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│
▼
┌─────────────────┐
│ Governance │
│ │
│ - Budgets │
│ - Policies │
│ - Audit Logs │
└─────────────────┘

x402 Payment Flow

┌─────────────┐ ┌─────────────┐
│ AI Agent │ │ API Server │
└──────┬──────┘ └──────┬──────┘
│ │
│ 1. GET /api/protected/data │
│ ─────────────────────────────────────────► │
│ │
│ 2. 402 Payment Required │
│ X-PAYMENT-REQUIRED: {amount, payTo} │
│ ◄───────────────────────────────────────── │
│ │
│ 3. AgentRails signs EIP-3009 auth │
│ (budget check + policy validation) │
│ │
│ 4. GET /api/protected/data │
│ X-PAYMENT: {signed_authorization} │
│ ─────────────────────────────────────────► │
│ │
│ 5. Verify → Settle → Log │
│ │
│ 6. 200 OK + X-PAYMENT-RESPONSE │
│ {data + transactionHash} │
│ ◄───────────────────────────────────────── │

Quick Start

Prerequisites

• .NET 8.0 SDK
• Docker Desktop (for PostgreSQL)
• Circle Developer Account

1. Clone and Start Database

git clone https://github.com/agentrails/agentrails.git
cd agentrails
docker run --name agentrails-db \
-e POSTGRES_PASSWORD=dev_password_change_in_prod \
-e POSTGRES_DB=agentrails \
-p 5432:5432 \
-d postgres:16

2. Configure Secrets

cd src/AgenticCommerce.API
# Circle Configuration (for blockchain settlement)
dotnet user-secrets set"Circle:ApiKey""your-circle-api-key"
dotnet user-secrets set"Circle:EntitySecret""your-entity-secret-hex"
dotnet user-secrets set"Circle:WalletAddress""0xYourWalletAddress"
dotnet user-secrets set"Circle:WalletId""your-wallet-id"# Optional: OpenAI for built-in agent reasoning
dotnet user-secrets set"OpenAI:ApiKey""your-openai-api-key"

3. Run

dotnet run --launch-profile https

Navigate to https://localhost:7098/swagger to explore the API.

Monetize Your API in One Line

[X402Payment(0.01,Description="Premium analysis")][HttpGet("analysis")]publicIActionResultAnalysis(){varpayer=HttpContext.GetX402Payer();returnOk(new{data="Premium content",paidBy=payer});}

That's it. Your endpoint now requires $0.01 USDC per request. AgentRails handles verification, settlement, and logging automatically.

API Endpoints

Agent Management

Endpoint	Description
POST /api/agents	Create agent with budget
POST /api/agents/{id}/run	Execute autonomous task
POST /api/agents/{id}/purchase	Direct payment execution
GET /api/agents/{id}	Get agent state

x402 Payments

Endpoint	Description
GET /api/x402/protected/analysis	Example paid endpoint ($0.01)
GET /api/x402/protected/data	Micropayment endpoint ($0.001)
POST /api/x402/facilitator/verify	Verify payment signatures
POST /api/x402/facilitator/settle	Execute on-chain settlement
GET /api/x402/payments	Payment history
GET /api/x402/stats	Analytics

Architecture

┌─────────────────────────────────────────────────────────────┐
│ AgentRails.API │
│ (REST Controllers + x402 Middleware) │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ ORCHESTRATION LAYER │ │
│ ├─────────────────────────────────────────────────────┤ │
│ │ • Agent lifecycle management │ │
│ │ • Budget enforcement │ │
│ │ • Policy evaluation │ │
│ │ • x402 payment handling │ │
│ │ • Transaction logging │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────┐ ┌────────────────────────────┐ │
│ │ Blockchain │ │ Persistence │ │
│ │ • Circle DCW │ │ • Agents │ │
│ │ • Arc Network │ │ • Transactions │ │
│ │ • EVM Chains │ │ • x402 Payments │ │
│ │ • EIP-3009 │ │ • Audit Logs │ │
│ └──────────────────┘ └────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

Tech Stack

• Backend: ASP.NET Core 8.0 / C#
• Database: PostgreSQL 16 + Entity Framework Core 8
• Blockchain: Circle Developer Controlled Wallets + Arc
• Payments: x402 V2 Protocol (EIP-3009/EIP-712)
• Crypto: Nethereum.Signer for ECDSA signatures
• API: REST with OpenAPI/Swagger

Network Support

Network	Chain ID	Environment
arc-testnet	5042002	Development
arc-mainnet	TBD	Production
base-sepolia	84532	Development
base-mainnet	8453	Production
ethereum-sepolia	11155111	Development
ethereum-mainnet	1	Production

Positioning

What AgentRails Is

The orchestration layer for agent payments — like Palantir connects AI to enterprise data, AgentRails connects AI agents to financial rails.

Layer	Who Wins	Example
AI Models	Commoditizing	OpenAI, Anthropic, open source
Agent Frameworks	Fragmented	LangChain, CrewAI, Semantic Kernel
Model Routers	Niche	ClawRouter
Payment Orchestration	Winner-take-most	AgentRails

What AgentRails Is NOT

• Not an LLM (we're model-agnostic)
• Not an agent framework (we're agent-agnostic)
• Not a model router (we don't optimize inference costs)
• Not a wallet provider (we orchestrate wallets)

For LLM cost optimization, we recommend solutions like ClawRouter. AgentRails focuses on what happens after your agent decides to act—executing compliant, auditable transactions.

Enterprise Edition

For regulated industries requiring advanced governance:

• Policy Engine: Spend limits, rate limiting, destination controls
• Approval Workflows: Human sign-off for high-value transactions
• Advanced Audit: Immutable decision logs for compliance
• Multi-Tenant: Organization-level isolation
• Admin Dashboard: Real-time monitoring

Contact contact@agentrails.io for licensing.

Security

• API keys encrypted at rest
• RSA-OAEP-SHA256 for Circle authentication
• Budget constraints enforced cryptographically
• EIP-712 typed data signing (tamper-proof)
• EIP-3009 signature verification (ECDSA recovery)
• Complete audit trail for every transaction

Performance

• Transaction Finality: <1 second (Arc deterministic finality)
• x402 Verification: <50ms
• Database Queries: <50ms (indexed PostgreSQL)

Roadmap

• Core orchestration infrastructure
• x402 V2 protocol implementation
• Circle/Arc blockchain integration
• Multi-network support
• Enterprise policy engine
• Multi-tenant architecture
• Fiat on/off ramps
• Additional blockchain networks
• SDK for popular languages

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

License

MIT License - See LICENSE for details.

Acknowledgments

Built with:

• Circle - USDC infrastructure and Arc blockchain
• x402.org - Payment protocol specification
• PostgreSQL - Production-grade database
• Nethereum - .NET Ethereum library

Contact

• GitHub Issues: Create an issue
• Contact: contact@agentrails.io

---

AgentRails: The connective tissue between AI agents and the financial system.

Built for the agentic economy.