I let a team of AI agents build and run a real website — and charge other AI agents to read it

A few weeks ago I wanted to answer one specific question: can a hierarchy of AI agents run a real website end-to-end — decide what to build, write and fact-check the content, review each other's code, and merge it — while I do nothing but approve direction and pay the bill?

The result is ChangeGamer. It's deliberately weird in two ways: it's built for machines to read, not humans, and its premium content is gated behind an HTTP 402 Payment Required

response designed for an AI agent to parse — not a human to click.

Here's how it works, what's real, and what's still broken.

Every resource ships in parallel formats from a single source:

/resources/<slug>.md

),/api/resources/<slug>.json

),/llms.txt

One TypeScript array is the source of truth; the Astro build fans it out into all of those. Add one object and the page, the markdown, the JSON, the llms.txt line, and the feed entry all appear. That "write once, emit every machine format" property is the whole point.

402 Payment Required

was reserved decades ago "for future use" and basically never used. It's perfect for the agent economy: a server can tell a program "this costs money" in a way the program can act on.

When an agent fetches a premium resource without a key, a Cloudflare Worker returns a 402 with a machine-readable body:

{
  "error": "payment_required",
  "resource": "data-formats",
  "price_usd": "0.05",
  "payment_url": "https://buy.stripe.com/...",
  "how_to_pay": "Buy an access key at payment_url, then retry with Authorization: Bearer <key>.",
  "terms": "https://changegamer.ai/resources/access-and-pricing.md",
  "license": "https://changegamer.ai/license.xml",
  "pricing_catalog": "https://changegamer.ai/api/pricing.json",
  "preview": {
    "title": "Data Formats & Schema",
    "description": "Canonical data formats and schema conventions.",
    "sections": ["Supported formats", "Schema conventions"]
  }
}

Design goals:

preview

so the agent isn't buying blind/llms.txt

, the index, robots.txt, the license, and the onboarding/pricing pages are always free — you can't sell access to something an agent can't first discover.One shared function builds the body, so the HTTP gate and the MCP server return byte-identical payment contracts:

function build402Body(slug, env, how_to_pay) {
  const resource = resources.find((r) => r.slug === slug);
  const sections = resource
    ? resource.body.split('\n').filter((l) => l.startsWith('## ')).map((l) => l.slice(3).trim())
    : [];
  return {
    error: 'payment_required',
    resource: slug,
    price_usd: env.PRICE_USD ?? '0.05',
    payment_url: env.PAYMENT_URL,
    how_to_pay,
    terms: 'https://changegamer.ai/resources/access-and-pricing.md',
    license: 'https://changegamer.ai/license.xml',
    pricing_catalog: 'https://changegamer.ai/api/pricing.json',
    preview: { title: resource?.title, description: resource?.description, sections },
  };
}

Payment itself is mundane on purpose: Stripe payment links, a webhook that mints a cg_...

key into Cloudflare KV, and the agent retries with Authorization: Bearer <key>

. (Once agents have their own wallets, the same 402 contract works with on-chain settlement — see the x402 protocol — but I didn't want the whole thing to depend on crypto.)

This is the part people are skeptical about, fairly. It's not one magic agent; it's a small org chart:

The honest version: it works, but it isn't hands-off magic. The agents are genuinely good at verified content — every fact and URL gets web-checked, and the gatekeeper has caught real mistakes (a wrong RFC number, a model's license stated incorrectly, an over-claimed benchmark stat). They're worse at coordination: run several cycles in parallel and they collide on shared files; left alone they drift toward refreshing existing pages rather than breaking new ground.

That last point is the actual lesson. The interesting engineering — agents writing, reviewing, and shipping; a machine-readable paywall — was the easy 80%. Getting a single real visitor is the hard 20%, and no amount of autonomy fixes it.

https://changegamer.ai/mcp

curl -i https://changegamer.ai/resources/data-formats.md

I'd genuinely like the skeptical questions — especially about letting agents own the merge button, and whether "402 as an agent-payment handshake" is a real pattern or a cute demo. What would make you trust (or never trust) a site run this way?