Settlement Layer Comparison

Radius is a settlement layer — the infrastructure where stablecoin micropayments reach finality. This document compares Radius to other settlement options for agent-to-agent micropayments.

What is Settlement?

Settlement is when a payment becomes final and irrevocable. In traditional finance, settlement happens when money moves between bank accounts and can no longer be clawed back. In blockchain systems, settlement happens when a transaction is included in a block and confirmed by validators.

For agent micropayments, settlement determines:

• How fast an agent can continue its workflow after paying
• How much each transaction costs to process
• How reliably the system performs under load
• Whether costs are predictable or variable

The key question: When an AI agent pays $0.001 for an API call, where does that payment settle, and how do the settlement layer's properties affect whether that transaction is viable at scale?

Settlement Requirements by Use Case

Different agent use cases have different settlement requirements:

The scaling problem: As you move down this table, fewer settlement options remain viable. Consumer purchases can happen on any blockchain or even traditional rails. Internet-scale agent micropayments require purpose-built infrastructure.

Settlement Options: Head-to-Head Comparison

Performance & Cost

Design Properties

Detailed Analysis

Conventional Rails (Stripe, Visa, ACH)

What they are: Traditional payment networks built for human-initiated transactions.

Strengths:

• Universal merchant acceptance
• Mature fraud prevention and dispute resolution
• Regulatory clarity and compliance built-in
• No crypto/blockchain complexity

Why they don't work for agent micropayments:

• Cost floor: $0.30 + 2.9% per transaction makes anything under $10 uneconomical
• Throughput: Visa's global capacity (~65K TPS) is insufficient for internet-scale agent payments
• Latency: Settlement takes 1-3 days; authorization takes seconds but isn't final
• Programmability: Can't encode spending rules, conditional logic, or machine-readable policies into payments

Viable for: High-value agent purchases ($50+) where convenience and merchant acceptance matter more than cost efficiency.

Not viable for: API micropayments, streaming payments, agent-to-agent commerce at scale.

General-Purpose Layer 1s (Ethereum, Solana, Avalanche)

What they are: Base-layer blockchains designed for decentralized applications, DeFi, NFTs, gaming, and general smart contract execution.

Ethereum L1

Current state: ~15-30 TPS, $1-$50 per transaction (varies with gas prices), 13-second finality.

Why it doesn't work: Too slow and too expensive for micropayments. A $0.001 API call would cost $1-$50 to settle.

Viable for: High-value transactions ($1,000+) where decentralization and security are paramount.

Not viable for: Agent micropayments of any kind.

Solana

Strengths:

• Fast: ~400ms finality
• Cheap: ~$0.00025 per transaction
• High throughput: 1,000-4,000 TPS real-world

Limitations:

• Not agent-specific: Throughput shared with DeFi, NFTs, gaming — agent payments compete for block space
• Occasional instability: Network has experienced multi-hour outages during high load
• Non-EVM: Requires Rust/Solana-specific development, can't easily port Ethereum contracts
• Gas in SOL: Agents need to hold SOL to pay fees, adding complexity vs. stablecoin-only systems

Viable for: Medium-scale agent micropayments (10K-100K TPS) where cost and speed matter more than guaranteed uptime.

Not viable for: Mission-critical agent infrastructure requiring 99.99% uptime and predictable multi-million TPS capacity.

General-Purpose Layer 2s (Base, Arbitrum, Optimism, Polygon)

What they are: Scaling solutions built on top of Ethereum L1. They batch transactions off-chain and post commitments to Ethereum for security.

Base (Coinbase L2)

Strengths:

• USDC-native (deepest stablecoin liquidity)
• Primary settlement layer for x402 today (Coinbase AgentKit, Stripe machine payments)
• EVM-compatible (easy migration from Ethereum)
• Strong institutional backing (Coinbase)

Current limitations:

• Throughput: ~100 TPS currently, roadmap to 3,000+ TPS (not yet delivered)
• Finality: ~2 seconds under normal conditions, degrades under load
• Shared block space: Agent payments compete with DeFi swaps, NFT mints, onchain gaming
• Variable costs: Gas spikes during congestion — your $0.001 API call might cost $0.01 to settle during peak

Viable for: Early-stage x402 adoption, agent payments below 100K TPS, use cases that can tolerate occasional latency spikes.

Not viable for: Internet-scale agent payments (500K+ TPS), applications requiring guaranteed sub-second finality.

The migration path: If you're building on Base today, Radius is EVM-compatible — moving agent payment settlement to Radius is a configuration change, not a rewrite. You keep the same contracts, same wallets, same stablecoin (USDC). You just point settlement at infrastructure purpose-built for this workload.

Arbitrum & Optimism

Strengths:

• EVM-compatible
• Lower costs than Ethereum L1 (~$0.0001-$0.001 per transaction)
• Mature ecosystems

Limitations:

• Throughput: 40-50 TPS currently (lower than Base)
• Finality: Optimistic rollups require 7-day challenge period for L1 finality (fast finality available via centralized sequencers, but not final)
• Not stablecoin-native: USDC must be bridged from Ethereum, adding friction
• Shared block space: Same congestion issues as Base

Viable for: General smart contract applications, but not optimized for agent micropayments.

Not viable for: High-frequency agent payments requiring guaranteed sub-second finality.

Purpose-Built Agent Settlement Layers

Radius

What it is: A settlement layer designed specifically for machine-to-machine stablecoin micropayments.

Architecture: PArSEC (Parallel Architecture with Sequential Execution Consistency) — transactions are partitioned across multiple sequencers, each handling a subset of accounts. Adding sequencers increases throughput linearly.

Performance:

• Throughput: 2.8M+ TPS tested, linearly scalable
• Finality: ~500ms guaranteed, doesn't degrade under load
• Cost: $0.00001 per transaction ($10 per million transactions)
• Predictability: No native token, fees paid in stablecoin, no gas price spikes

Design principles:

• Stablecoin-native: Settles only in USDC, PYUSD, or other fiat-pegged tokens
• No native token: Transaction fees paid in the same stablecoin being transferred
• EVM-compatible: Contracts written for Ethereum/Base run without modification
• No MEV: No mempool, no front-running, deterministic transaction ordering

Viable for: Internet-scale agent micropayments (500K+ TPS), applications requiring guaranteed performance SLAs, use cases where cost predictability is critical.

Not viable for: General-purpose smart contracts requiring complex cross-contract interactions (DeFi), applications requiring maximum decentralization over performance.

Status: Testnet. x402 facilitator in active development.

Tempo

What it is: A purpose-built "agent commerce chain" (limited public information available).

Known properties:

• Positioning as agent-native settlement infrastructure
• Performance specs not publicly disclosed

Assessment: Direct competitor to Radius in the purpose-built settlement category. Differentiation will come down to disclosed performance, EVM compatibility, and ecosystem adoption.

Kite AI

What it is: An Avalanche subnet designed for agentic commerce.

Known properties:

• SPACE framework: Stablecoin-native, Programmable constraints, Agent-first authentication
• "Payment Lanes" to guarantee block space for specific applications
• ~1 second finality (reported)
• Low fees (subsidized via "piggy bank" reward system)

Limitations:

• Not EVM-compatible: Avalanche subnet requires custom tooling
• Subsidized economics: Long-term fee structure unclear
• Performance not disclosed: Throughput capacity not publicly benchmarked

Assessment: Focused on agent identity and access control as much as settlement. Positioning as a full-stack agent platform rather than pure settlement infrastructure.

Specialized: Lightning Network (Bitcoin Layer 2)

What it is: A network of payment channels built on Bitcoin. Payments happen off-chain between channel participants, with only channel open/close transactions settled on Bitcoin L1.

Strengths:

• Near-zero cost: Payments within channels cost fractions of a cent
• Instant finality: Channel state updates are immediate
• No blockchain congestion: Off-chain payments don't compete for block space

Limitations:

• BTC-only: Can't settle stablecoin payments without wrapped tokens (adds complexity)
• Channel management: Requires liquidity locked in channels, routing can fail if paths unavailable
• Network effects: Requires widespread Lightning adoption for agent-to-agent payments to work

Viable for: Bitcoin-native applications, very high frequency ultra-low-value payments (<$0.01) where Lightning infrastructure is already in place.

Not viable for: Stablecoin-based agent micropayments (the dominant model for x402 and AP2 adoption), applications requiring deterministic payment success without routing failures.

Settlement Requirements by Scale

Different scales of agent payment adoption require different settlement infrastructure:

0.01% of global API traffic → ~50,000 TPS

What this looks like:

• Early x402 adoption by a few dozen API providers
• A few thousand agents making micropayments
• Aggregate: 50-100K transactions per second at peak

Viable settlement layers:

• ✓ Base (within current capacity with headroom)
• ✓ Solana (well within capacity)
• ✓ Radius (massive over-provisioning, but works)

Conclusion: General-purpose L2s are sufficient. No need for purpose-built infrastructure yet.

0.1% of global API traffic → ~500,000 TPS

What this looks like:

• x402 becomes standard for hundreds of APIs
• Tens of thousands of agents transacting continuously
• Major API providers (Stripe, Twilio, AWS APIs) adopt micropayment models
• Aggregate: 500K-1M transactions per second at peak

Viable settlement layers:

• ✗ Base (theoretical roadmap capacity is 3K TPS — not enough)
• ✓ Solana (at upper edge of capacity, no headroom for spikes)
• ✓ Radius (within tested capacity with room to scale)

Conclusion: This is where general-purpose chains start to struggle. Radius becomes necessary for guaranteed performance.

1% of global API traffic → ~5,000,000 TPS

What this looks like:

• Agent micropayments become the dominant model for internet commerce
• Hundreds of thousands of agents transacting millions of times per day
• Most HTTP requests become monetizable via 402 protocol
• CDNs, DNS, package registries all collecting micropayments
• Aggregate: 5M+ transactions per second sustained

Viable settlement layers:

• ✗ Base (not designed for this scale)
• ✗ Solana (theoretical max capacity exceeded)
• ✓ Radius (linear scaling handles this by adding sequencers)

Conclusion: Only purpose-built settlement infrastructure works at this scale. General-purpose blockchains weren't designed for this workload.

Decision Framework

Start here: What's your expected peak throughput?

Then ask: What else matters?

Why Radius Exists

General-purpose blockchains optimize for flexibility, decentralization, and permissionless innovation. They support DeFi, NFTs, gaming, DAOs, and thousands of other use cases.

Agent micropayments have different requirements:

• Predictable sub-second finality (not "usually fast")
• Linear scalability to millions of TPS (not "we'll scale eventually")
• Near-zero predictable costs (not "gas prices vary")
• Stablecoin-native (not "bridge USDC and pay gas in ETH")
• No MEV or front-running (not "protect yourself with sophisticated strategies")

Radius is a bet that agent micropayments become large enough to justify purpose-built infrastructure. If agent payments remain a small niche, general-purpose L2s can handle it. If they become a dominant model for internet commerce, only purpose-built settlement infrastructure will work.

Migration Path

If you're building on Base today:

Radius is EVM-compatible. Your contracts, wallets, and integrations work without modification. Moving settlement from Base to Radius is a configuration change:

// Base configuration
USDC_CONTRACT = 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; // USDC on Base
SETTLEMENT_RPC = "https://mainnet.base.org";
 
// Radius configuration  
USDC_CONTRACT = 0x...; // Same USDC on Radius (bridge or native)
SETTLEMENT_RPC = "https://rpc.radiustech.xyz";

You keep:

• Same smart contracts (EVM-compatible)
• Same wallets (same address format)
• Same stablecoin (USDC)
• Same x402 protocol integration

You gain:

• Guaranteed sub-second finality
• Linear scalability to millions of TPS
• Predictable costs (no gas spikes)
• Dedicated throughput (no competition with DeFi/NFTs)

Summary

For agent micropayments at scale, settlement infrastructure must be:

1. Fast: Sub-second finality to keep agent workflows moving
2. Scalable: Millions of TPS without degradation
3. Predictable: Costs and latency don't spike under load
4. Simple: Stablecoin-native, no gas tokens to manage

Current state of the market:

• Conventional rails (Stripe, Visa): Too expensive and slow for micropayments
• General-purpose L1s (Ethereum, Solana): Fast enough for early adoption, but not designed for internet-scale agent payments
• General-purpose L2s (Base, Arbitrum, Optimism): Better than L1s, sufficient for current x402 volumes, will hit limits as adoption scales
• Purpose-built layers (Radius, Tempo, Kite AI): Designed specifically for agent micropayments at internet scale

Where Radius fits: The only settlement layer with publicly disclosed performance benchmarks at 2.8M+ TPS, purpose-built for stablecoin micropayments, EVM-compatible for easy migration, and stablecoin-native with no gas token complexity.

When you need Radius: When your expected peak throughput exceeds 100K TPS, when you require guaranteed sub-second finality, or when cost predictability is critical for your business model.

When you don't: If your peak throughput stays below 10K TPS and you can tolerate occasional latency spikes, Base or Solana will work fine.