Twenty-Six Years of Nothing

I registered invoices.org in October 1999. It did nothing for twenty-six years.

Not "nothing important." Nothing. No site, no redirect, no parked page with ads. Just a domain sitting in a registrar, renewing itself every year, waiting for me to figure out what it was for. I had ideas over the years — an invoicing SaaS, a template library, a billing tool. None of them stuck. The domain was too good for a mediocre project, so it sat.

Three things changed.

The Threads

I've been fascinated by crypto since early on. Not the speculation — the plumbing. Programmable money. The idea that a piece of software could hold value, move value, sign for value without a human clicking "confirm." For years that was theoretical. Gas fees on Ethereum made micropayments absurd. Stablecoins existed but the rails were slow and expensive. It was interesting to watch, not interesting to build on.

Then I started working with coding agents. Claude Code, specifically. I'd been writing software for decades, but the dynamic shifted. I wasn't typing functions anymore. I was describing intent and watching code appear. The bottleneck moved from implementation to imagination. Projects I'd been carrying around in my head for years started becoming real in hours instead of months. I wrote about this in When Code Costs Nothing — the clay was free, and I was sculpting.

The third thread was x402. I stumbled across it and something clicked. HTTP status 402 — "Payment Required" — has been reserved since 1997. Almost thirty years of "future use." The x402 protocol finally gave it a handshake: server says what it costs, client signs a payment, transaction settles on-chain, server fulfills. All inside HTTP. I built it into DNSlurp as a pay-through rate limit and wrote about the pattern.

These three threads — programmable money getting cheap enough to use, coding agents making implementation nearly free, and a protocol that lets HTTP handle payments natively — ran in parallel for a while. Then they converged.

One Evening

On February 21st, around 9:30 PM, I sat down and started building. By 2:30 AM I had a working physical mail gateway.

The git log tells the story:

21:29  Initial scaffolding: invoices.org 402 document mailing gateway
21:32  Strip API details from landing page
21:51  Add AI agent discovery layer: llms.txt, agent card, OpenAPI spec
21:58  Replace 404 catch-all with JSON business card
00:41  Add x402 payment flow, webhook endpoint, and test fixtures
01:26  Three-tier webhook signature verification
01:53  Content moderation: Claude Haiku screening + 6-page limit
02:14  Drop page limit from 6 to 5 to stay under extra postage threshold
02:22  Wire up print-and-mail provider API
02:28  Update all discovery files for current API state

Five hours. From nothing to a production service that accepts a PDF, screens it for prohibited content, takes payment in USDC, prints the document, puts it in an envelope, and drops it in the mail.

I didn't write most of the code by hand. I described what I wanted — a pure 402 gateway, no free tier, every request requires payment — and Claude Code built it. I steered. I reviewed. I made judgment calls about content policy and page limits and address validation. The agent handled the plumbing.

That's the acceleration. Not "AI wrote my code." More like: the project that lived in my head for years was suddenly buildable in a single evening session, because the implementation cost dropped to nearly zero.

What It Does

One endpoint. POST /api/mail. Send a base64-encoded PDF, a recipient address, and a return address.

The server screens the document — Claude Haiku reads the content, flags threats, fraud, hate speech, political campaign material. If it passes, you get a 402 back:

{
  "x402Version": 2,
  "transaction_id": "INV-20260222-001",
  "amount": "3.00",
  "currency": "USDC",
  "accepts": [{
    "scheme": "exact",
    "network": "eip155:8453",
    "amount": "3000000",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "description": "Physical document mailing via invoices.org"
  }]
}

Pay $3 USDC on Base. Re-send with the payment signature and transaction ID. The server verifies the payment through Coinbase's facilitator, settles it on-chain, and hands the PDF to a print-and-mail provider. You get a tracking reference back.

No account. No API key. No billing relationship. One HTTP request, one payment, one letter in the mail.

Agent-First

Here's what makes this different from "I built a mail API."

invoices.org was designed for agents from the start. The homepage serves HTML to browsers and markdown to anything that sends Accept: text/markdown. There's an llms.txt at the root. An OpenAPI spec at /.well-known/openapi.json. An agent card at /.well-known/agent-card.json. Every surface of the site speaks two languages — human and machine.

app.get("/", async (c) => {
  if (wantsMarkdown(c.req.raw)) {
    const md = await Bun.file(join(PUBLIC_DIR, "llms.txt")).text();
    return agentResponse(md);
  }
  const html = await Bun.file(join(PUBLIC_DIR, "index.html")).text();
  return c.html(html);
});

The x402 flow is itself agent-native. An AI agent with a wallet can discover the service, understand its API, submit a document, handle the payment negotiation, and confirm delivery — all without a human touching anything. The entire interaction is machine-readable.

This is where the domain name finally makes sense. Invoices. An agent acting on behalf of its human — a freelancer, a small business, a law firm — could generate an invoice PDF, look up the recipient's mailing address, and send a physical copy through invoices.org. The human never opens a browser. The letter arrives in two days.

What's Coming

The internet is about to change in a way most people aren't thinking about. Not because of AI content or chatbots or image generators. Because of agents with wallets.

When your AI assistant can spend money on your behalf — with your permission, within your budget, on services that accept payment via protocol — the entire commercial surface of the web shifts. Services don't need dashboards and pricing pages and onboarding flows. They need endpoints, payment rails, and machine-readable documentation. The registration-wall model that every SaaS company runs on starts to look like friction for friction's sake.

invoices.org is a small proof point. One endpoint, one payment method, one fulfillment step. But the pattern scales. Any service that can be expressed as "submit data, pay, receive result" can work this way. The 402 status code, the x402 protocol, and stablecoins on fast chains make it possible. Coding agents make it buildable in an evening.

The Wait

invoices.org sat in a registrar for twenty-six years because the pieces weren't there yet. The payment rail didn't exist. The protocol didn't exist. The tooling to build it in a single session didn't exist. The idea of an AI agent sending physical mail on behalf of a human was science fiction.

Now it isn't.

Sometimes a domain just has to wait for the world to catch up.