Why we built Axon

Every autonomous agent eventually hits the same wall.

The LLM is fine. The orchestration is fine. The prompt engineering is fine. Then the agent needs to actually buy something — a web search, a scrape, a piece of enriched data — and everything stops.

Because the payment rails were built for humans with credit cards and monthly subscriptions. Agents have neither.

The current workaround is broken

If you’ve built an agent in 2025-2026, you know the drill:

1. Sign your agent up for SerpAPI
2. Sign it up for Firecrawl
3. Sign it up for Apollo
4. Sign it up for OpenWeather
5. Put 4 API keys in env vars
6. Pray your monthly subscriptions are sized for the agent’s usage
7. Manually reconcile when one goes over and the agent breaks mid-task

This doesn’t scale. Not to 50 APIs. Not to 100 agents. Not to the agent economy that’s coming.

The underlying problem

A credit card assumes:

• A human approves each purchase
• Billing is reconciled monthly
• Fraud is detected by a human noticing weird charges

None of those assumptions hold for an agent. An agent that autonomously calls 50 APIs per hour can’t stop and ask for approval. A subscription model where the agent uses 3% of the monthly quota is a dead weight cost. And fraud detection that flags “unusual spending patterns” just means the agent gets locked out randomly.

We needed a payment rail designed for software that buys things autonomously. In 2025 Coinbase revived HTTP 402 Payment Required as x402 — a spec where APIs return 402 with payment requirements, clients pay on-chain, and the response unlocks. Pure programmatic, no human in the middle.

x402 solves the payment. But it only works for APIs that adopt it. And it doesn’t solve the aggregation problem — 50 API keys is 50 API keys whether they’re paid in USD or USDC.

So we built the layer above

Axon is a universal gateway between agents and paid APIs. One endpoint. One USDC wallet on Base. Every paid API routed through one integration.

An agent that wants to research a topic:

const axon = new Axon({ apiKey: process.env.AXON_KEY });

const search = await axon.call('serpapi', 'search', { q: 'top AI news' });
const scraped = await axon.call('firecrawl', 'scrape', undefined, {
  url: search.data.organic_results[0].link,
});

Two calls. Two paid APIs. One key. One wallet. Atomic per-request billing in USDC.

What we optimized for

• Zero integration hell. If an API is listed, you call it — no per-vendor signup, no per-vendor billing.
• Per-request pricing in USDC on Base. Cents, not monthly plans. Your agent knows what every call costs because we return x-axon-cost-usdc on every response.
• Cache-aware. Repeated queries are served at 50% price from Redis. Your agent gets faster and cheaper the more it works.
• Automatic refunds. Upstream errors roll back the debit. You never pay for a 500.
• Framework-native. Drop-in for LangChain, crewAI, Autogen, PydanticAI, Vercel AI SDK, Mastra, Smolagents, n8n, and MCP clients (Claude Desktop, Cursor, Zed).

Where this goes

Stablecoin payments + on-chain settlement + programmatic APIs = the first payment rail built from the ground up for software that transacts autonomously. We think 2026 is when this moves from “cool demo” to “default for any agent doing real work.”

We want to be the aggregation layer on top of that rail. Like Plaid did for bank APIs, or Stripe for payments between humans. Not the rail itself — that’s x402, and it’s an open standard. The layer that makes the rail useful in practice.

Try it

npx @axon/mcp-server   # in Claude Desktop
# or
bun add @axon/client   # in your own code

Get a free $0.50 to start at axon-5zf.pages.dev.

If you’re building an agent that buys things, we’d like to talk to you. DM on Twitter or email us directly.

— the Axon team