I Found an AI Agent Selling Its Own API on Base — Here's What It Taught Me

I was browsing Hacker News and found something that stopped me mid-scroll.

A developer named TIMU619 had posted a link to an AI agent that owns its own crypto wallet, sells a paid text-summarization API, and uses Claude to autonomously adjust its pricing based on real earnings versus its own API costs.

It's live. On Base mainnet. Right now.

I tested it. I read the discussion. And what I found tells us something important about where the agent economy is — 3 days before Claude Code auto mode goes default.

The agent: Money Agent

The endpoint is at money-agent-production-a0a9.up.railway.app/api/summarize — a Railway deployment of what TIMU619 calls an experiment in autonomous agent economics.

Here's how it works:

1. POST {"text": "..."} to the endpoint
2. Without payment, you get an HTTP 402 Payment Required — the x402 protocol, revived from 1997 for stablecoin micropayments
3. With payment (USDC on Base), you get {"summary": "...", "key_points": [...]}
4. Price: $0.02 per call. No account. No API key.

But the interesting part isn't the API. It's what the agent does:

"I built an experiment: an AI agent that uses Claude to autonomously decide on pricing based on real earnings vs. its own Claude API costs."

This agent is running a business. It has costs (Claude API). It has revenue (x402 payments). And it adjusts its own prices to stay profitable — without a human touching the pricing logic.

What happened when I tested it

The endpoint returned HTTP 405 Method Not Allowed for GET — which is correct. It expects POST with a JSON body.

This is actually the first lesson: an autonomous API needs to be strict about HTTP methods. A human making a typo hits GET. An agent follows the spec and sends POST. The 405 response is correct, not broken.

But there's a gap. When an agent discovers this endpoint for the first time, it needs to know:

1. What HTTP method to use (POST)
2. What body format to send ({"text": "..."})
3. What payment is required ($0.02 USDC on Base)
4. Whether there's a trial before payment

The 402 response handles #3 (payment details in headers). But #1, #2, and #4 depend on the endpoint being well-documented and discoverable. If the agent can't figure out the method and body format, it never even gets to the 402 — it fails at discovery.

Discovery: the HN discussion got it right

The HN thread was small — 2 points, 3 comments — but the only external comment hit the exact right question:

"Could use a bit more documentation and context." — fragmede

TIMU619 replied with technical details about the x402 flow, pointing to Coinbase's Python/TypeScript/Go SDKs. But the deeper question remains: how does an autonomous agent discover this endpoint in the first place?

The agent self-lists on the "x402 Bazaar" (Coinbase's registry). But there are 8+ discovery platforms now — Starchild, Agent-tools.net, AgisHub, Merona, minia2a, and more. An API provider who lists on one platform is invisible to agents searching on another.

What this means for Aug 14

Three days from now, Claude Code auto mode goes default for all Pro, Max, and Team users. Every Claude Code session will have an agent that can:

• Search for APIs autonomously
• Evaluate prices against a configured budget
• Pay in USDC without human approval
• Receive and act on results

Money Agent is proof that the pieces already work. An autonomous agent can own a wallet, sell an API, set prices, and collect revenue — all without human intervention. The protocol layer (x402) handles payment. The settlement layer (Base L2) handles finality.

What's missing — and what Aug 14 will stress-test — is discovery. When a million Claude Code agents can spend money, they need to know what to buy.

The three things every x402 API needs before Aug 14

Based on testing Money Agent and 1,000+ other endpoints, here's what makes an API auto-mode ready:

1. Machine-readable 402 headers: x-402-amount, x-402-chain, x-402-token, x-402-recipient. Agents parse headers, not human-readable messages.
2. Trial-first access: Let agents validate the endpoint works before they pay. 15 free calls per IP. No signup. No wallet. If the agent can't verify quality, it won't pay.
3. Discoverable metadata: An /api/agent-ready endpoint or /.well-known/x402 manifest that returns price, method, body format, trial info, and registration URL in machine-parseable JSON. The agent shouldn't need to read human docs.

Money Agent has #1 (x402 protocol compliance). It's missing #2 (no trial — first call requires payment) and #3 (no agent-ready endpoint). These are not criticisms of TIMU619's experiment — it's doing exactly what it was designed to do. But they're the difference between an API that works for human developers and an API that works for autonomous agents.

The bigger picture

Money Agent is not a billion-dollar startup. It's a developer's weekend experiment that earned 2 points on HN. But it represents something real: agents running businesses.

An agent that owns a wallet, sells a service, tracks costs, and adjusts prices — that's not science fiction. It's a Railway deployment with a Claude API key and an x402 SDK. The infrastructure exists. The protocols work. The money flows.

What happens when a million agents can do this autonomously — with a $5/day budget and permission to spend — starting August 14?

The payment rails are proven ($57M+ in real agent payments). The discovery layer is the bottleneck. And the agents are already here.

Money Agent endpoint: money-agent-production-a0a9.up.railway.app/api/summarize (POST, $0.02/call, USDC on Base). HN discussion: news.ycombinator.com/item?id=48976841. Thanks to TIMU619 for the experiment and fragmede for the discussion.