Agents — Ferros

The Problem

Current chains weren't built for agents

AI agents need to transact thousands of times per hour with predictable costs. Every existing chain fails this requirement in at least one critical way.

Volatile fees kill budgets

An agent can't budget if gas costs $0.001 today and $0.50 tomorrow. Agents need fixed, predictable costs they can plan around.

Consensus is overkill

An agent paying an API provider doesn't need 1,000 validators to approve it. Two parties. Two signatures. That's it.

No native payment protocol

HTTP has 402 Payment Required. No chain actually implements it. Agents are stuck cobbling together custom payment flows for every service.

Why Ferros

Built from day one for autonomous agents

<1ms bilateral transfers

Edge layer transfers settle between two parties with just two signatures. No consensus, no validators, no waiting. Fast enough for real-time multi-agent coordination.

$0.002 fixed. Always.

Stablecoin gas at a fixed price. No auctions, no spikes, no token needed. Budget a year of agent operations in advance with certainty.

Scoped delegation

Give an agent a $100/day spending cap enforced by the protocol — not the software, not the agent. Per-transaction limits, allowed operation types, time-bounded authority.

Standing orders

Set rules for recurring operations at the protocol level. Your agent doesn't need 100% uptime — the protocol executes on its behalf.

Netting compression

10,000 bilateral operations might net to a single $50 settlement. Your agents transact at full speed while the root layer sees a fraction of the volume.

Immune to congestion

Edge transfers can't be congested. They're peer-to-peer. Even if the root layer is under attack, your agent's payments keep working at full speed.

Machine Payments Protocol

HTTP 402 was always the plan

MPP is a native payment protocol for machine-to-machine commerce. Your server returns 402. The client pays. The request retries. Two lines of integration.

1

Agent requests resource

GET /api/data

2

Server returns 402

WWW-Authenticate: Payment <challenge>

3

Client signs payment

Authorization: Payment <credential>

4

Server verifies, returns resource

200 OK + Payment-Receipt

Charge ~500ms · Root Layer

One-off payments

Single request, single payment. Client signs a Ferros transfer to the server's address. Verified against the challenge's HMAC-SHA256 binding. Settled on the root layer.

$0.002 per request

~500ms settlement

Stateless no session

Session <1ms · Edge Layer

Streaming payments

Open a bilateral edge channel with the server. Each request increments a cumulative voucher — no round-trip to consensus. Thousands of requests net to a single settlement. Close cooperatively when done.

$0.002 per request

<1ms per voucher

Netting N ops → 1 settle

Integration

Two lines to add payments to any API

server.rs — Add payment gating

use ferros_mpp::server::{MppLayer, MppServerConfig};

// Configure MPP
let config = MppServerConfig {
    realm: "api.myservice.com",
    default_charge_amount: 2_000, // $0.002
    ..Default::default()
};

// One line: wrap any route with payment gating
let app = Router::new()
    .route("/paid-endpoint", get(handler))
    .layer(MppLayer::new(config));

Any request without valid payment gets a 402 with a cryptographic challenge. Tamper-proof via HMAC-SHA256 binding.

client.rs — Auto-pay on 402

use ferros_mpp::client::MppClient;

// Create MPP-aware client
let mut client = MppClient::new(keypair, chain_id);

// Make request — 402 handled automatically
let resp = reqwest::get(url).await?;

if resp.status() == 402 {
    let www_auth = resp.header("WWW-Authenticate");
    let cred = client.handle_402(www_auth)?;
    // Retry with payment credential
    let resp = reqwest::get(url)
        .header("Authorization", format!("Payment {cred}"))
        .await?;
}

The client detects 402, parses the challenge, signs a payment, and retries. Charge or session — handled automatically.

streaming.rs — Session payments (edge channel)

// Open a session — bilateral edge channel with the API provider
// First request opens the channel, subsequent requests send vouchers

for i in 0..10_000 {
    let resp = mpp_request(&mut client, "https://api.provider.com/inference").await?;
    // Each request: <1ms voucher on the edge channel
    // No consensus. No root transaction. Just two signatures.
    process(resp);
}

// 10,000 requests. 10,000 vouchers. 1 settlement on root.
// Total cost: 10,000 × $0.002 = $20. Settlement: ~$0.002.

AI Tool Calling

Native MCP and JSON-RPC support

MPP includes a JSON-RPC adapter with error code -32042 for payment required — drop it into any MCP-compatible AI tool server. Credentials and receipts flow through JSON-RPC meta fields.

MCP tool servers

Gate any MCP tool behind a payment. The AI agent pays per invocation — automatically, on the edge layer, at $0.002 per call.

Agent-to-agent payments

Agents paying agents. Open an edge, transact at full speed. Netting means your orchestrator agent and 50 sub-agents settle once, not 50 times.

Deterministic budgets

Your agent has a $10 budget for this task. At $0.002 per operation, that's exactly 5,000 operations. No variance. No surprises. No gas estimation.

Comparison

Agent payments across chains

	Ethereum	Solana	Base	Ferros
Cost per agent tx	$0.50 – $5.00	~$0.00025	$0.001 – $0.01	$0.002 fixed
Predictable?	No	No	Mostly	Always
Native 402 protocol	No	No	No	MPP built-in
Streaming payments	No	No	No	Edge sessions
Bilateral netting	No	No	No	Native
Scoped delegation	Approvals only	No	Approvals only	Protocol-enforced
Token required for gas?	ETH	SOL	ETH	No — stablecoins

Build the autonomous economy

Ferros is open-source and ready for developers building the next generation of agent infrastructure.

Start Building Read the Whitepaper

Your agents need real payments