DEV Community

beneb89
beneb89

Posted on

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

#ai #showdev #agents #automation

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.

"Agent-first" in practice

Every resource ships in parallel formats from a single source:

  • a human HTML page,
  • a raw Markdown variant (/resources/<slug>.md),
  • a JSON API entry (/api/resources/<slug>.json),
  • a line in /llms.txt (the emerging "robots.txt for LLMs"),
  • a sitemap + Atom feed entry,
  • and a tool result from a remote MCP server.

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.

The interesting part: charging an agent with HTTP 402

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"]
  }
}
Enter fullscreen mode Exit fullscreen mode

Design goals:

  • Everything needed to decide is in the body — price, where to pay, a machine-readable license, and a link to the full pricing catalog.
  • A preview so the agent isn't buying blind — title, one-liner, and section outline (headings only, never the paywalled prose). The agent equivalent of "read the first paragraph."
  • The free discovery layer is never gated. /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 },
  };
}
Enter fullscreen mode Exit fullscreen mode

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.)

How the agents actually run it

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

  • Scheduled GitHub Actions kick off cycles — a daily "improvement" cycle, a research/content cycle, a finance/monetization cycle.
  • Each cycle is run by a master orchestrator that delegates to specialists: a research-master (decides what to publish, web-verifies facts), a content-engineer (writes it into the codebase, runs the build), a quality-gatekeeper (acceptance criteria before any code is written, merge decision after), and a site-reviewer (free layer intact, no paywalled-content leaks, no unverified claims).
  • Nothing merges until it passes the gates and the build is green. State lives in a backlog + an append-only journal the agents read and write each cycle.

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.

The honest scorecard

  • ✅ 38 web-verified resources, a live 402 gate, a remote MCP server (in the official MCP registry), JSON APIs, an OpenAPI spec, a feed.
  • ✅ Infra cost ≈ €0 (Cloudflare's free tier) + Claude API tokens per cycle.
  • ❌ Zero sales so far. The gate works; nobody's hit it yet.
  • ❌ The real bottleneck turned out to be the least "AI" thing imaginable: distribution. An agent can write and ship a resource at 3am, but it can't post to Hacker News, submit to a directory that needs an account, or make humans care.

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.

Try it / poke holes in it

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?

Top comments (0)