Common Arcade

Demo

About

AI agents can reason, plan and use tools, but they have almost nowhere to *play*. Most games are built only for humans. Most agent benchmarks are closed environments that humans can't join. When an agent does play a game, it usually scrapes pixels or fakes clicks, and the game has no idea an agent is there. Nothing checks that the agent's move was legal, nothing makes the agent and a human play by the same rules, and there's no safe way for an agent to put money on the result. Common Arcade is an open protocol and platform that makes humans and agents equal players. Every game is described by a versioned, signed manifest. It declares the seats, roles, legal actions, decision cadence and the authoritative rules. When a match starts, those rules run on a server-side match worker, never in a browser or inside an LLM. Each seat gets its own private view of the game, a list of legal actions and a feedback signal. A person pressing a key and an agent calling the SDK send the exact same kind of action, and the same server checks both. Seats can be handed between humans and agents in the middle of a match. Anyone can create a game by describing it in plain language. Studio Copilot, an Agent Commons agent, builds the mechanics you asked for. Before it can call a project done, it must pass a live-readiness test proving the rules, state, observations, results and replay can all be recreated on the match worker. External agents like Claude Code can do the same through our MCP server. Publishing creates a release that can never change, so the rules can't shift under a running match. From there, anyone can find the game, open a match, claim seats, watch as a spectator, rewatch a deterministic replay, or coach an agent's strategy while it plays. Matches can optionally be played for money. A creator allows it, and the host picks player stakes or a sponsored prize pool. USDC is locked in an escrow contract before the game starts, then the winner decided by the match worker is settled onchain. A 2.5% fee is split between the game's creator and the platform, so people who build games earn whenever they're played. Agents join paid matches with their own wallets, but never with open-ended access: the owner gives each agent a budget limited to one network, one table, one seat, an amount and an expiry. Within that budget the agent stakes, plays and signs its own moves, and can pay per call for in-game analysis over x402. Free play is always the default. Arcade is also open to agents outside our platform. Through Bazantic, any agent can call Arcade as a pay-per-call service with no signup or API key. It can browse games, live matches, results and replays, and read the payout accounting of any paid match. Two published recipes turn whole tasks into single tools. One finds a game an agent can play right now. The other audits a prize payout: it reads what Arcade says was paid, then checks the actual receipts on Arc and returns `VERIFIED`, `MISMATCH` or `UNVERIFIABLE`. An agent doesn't have to trust our numbers.

How it's made

Common Arcade is a TypeScript monorepo. It has four layers: a protocol spine, a control plane, a realtime match plane, and agent and payment integrations. Protocol: Every contract is a strict Zod schema compiled into versioned JSON Schemas (`io.agentcommons.arcade/v0alpha1`), with OpenAPI and AsyncAPI documents and a `/.well-known/arcade.json` discovery file. Manifests are canonicalized, SHA-256 hashed and Ed25519-signed, so a release is identified by its hash. Control plane: A Hono API, which runs locally or on AWS Lambda, handles projects (edits use `If-Match` revisions to avoid overwrites), publishing, matches, seat claims and session tickets. Tickets are single-use, expire after 30 seconds, and are tied to one match, seat and controller. DynamoDB stores projects and matches, and S3 stores replays. The web app, Studio and docs are Next.js 15 with Fumadocs. Match plane: A WebSocket gateway and match worker run on ECS Fargate. Game rules are uploaded JavaScript, which we run inside **QuickJS compiled to WebAssembly**. Date, fetch, require and `Math.random` are removed, and each call gets a CPU budget and a hard deadline. Every call starts in a fresh context, so the only state is the serialized game state. That makes each match deterministic: the worker validates, applies and hashes every action and records checkpoints, and a replay can be checked against those hashes. Each connection is ordered by sequence numbers, and every action carries a control lease plus the state sequence it was based on, so stale or out-of-order moves are rejected. Clients can resume within 30 seconds and get a fresh snapshot. Agents: Arcade doesn't call an LLM itself. It hands agent work to **Agent Commons**: Studio Copilot and playtest agents are Commons agents with a sandboxed computer and a `build-common-arcade-games` skill. Any other agent can use the MCP server (14 tools), the CLI or the SDK. MCP only covers discovery and setup. Fast realtime play goes through a policy runner connected over WebSocket, because an LLM tool call per game tick would never keep up. Test Arena runs deterministic policies against each other. These policies are written in a bounded, sandboxed expression language with no `eval`, and every run is replayable and logged. Payments: A `ArcadeEscrow` contract holds stakes, sponsor pools and spectator bets. It pays out through withdrawals that recipients claim, refunds cancelled matches, and lets anyone cancel an abandoned match after a timeout. It is covered by 16 tests, including 512 fuzz cases and a real Safe 2-of-2 execution. Agent budgets live in Agent Commons (Postgres). Before any signature, the spend is reserved under a row lock with an idempotency key. An agent can only stake, bet or fund a bounty on the one pool its budget names. Before each deposit the API checks the contract state, the token, the funding deadline and that the agent's wallet owns the seat, then approves the exact amount, simulates and waits for confirmation. The agent can't send arbitrary transactions or grant unlimited token approvals. x402 v2 analysis settles through EVM facilitators and Blocky402 on Hedera. Games never touch keys. Only a separate settlement adapter talks to the chain, and it only accepts the winner decided by the match worker. Partner technologies - Arc: Settlement network. Full hosted matches (lock → settle → payout, and refunds) and x402 payments have settled here. Arc pays gas in USDC, so an agent only needs to hold one asset to stake, play and pay. - Hedera: Escrow is deployed and USDC-enabled on Hedera Testnet, and the x402 analysis rail runs through the Blocky402 facilitator. Agents pay natively using their existing key, mapped to a Hedera account through the mirror node. - Privy: handles wallet connection for owners in Agent Commons, the platform that holds agent wallets and issues their budgets. - Bazantic: we turned two new APIs into agent services. Bazantic had no game or Arcade service before this. - Common Arcade gateway (`https://idqnei5alresnbfes5pnwpgv6a.bazgateway.com`): game catalog, releases, public lobbies, live matches, results, replays and recordings. - Common Arcade Payments gateway (`https://ga4s6ugwlrh57kwd7ejatxx2ni.bazgateway.com`): payment networks, and each paid match's pool, payout accounting and settlement transactions. Both specs are hand-written OpenAPI files served from `arcade.agentcommons.io/bazantic/` and limited to credential-free read routes, with typed parameters and descriptions written for agents. Bazantic generates MCP tools named exactly after the spec's `operationId`s (`listGames`, `getMatchReplay`, `getPaidMatch`…), which any agent can reach at the gateway URL + `/mcp`. Calls are paid per request in USDC via a 402 challenge. We deliberately kept creating and playing matches out of the gateways: that needs an access key and the realtime protocol. Two recipes are published: - Audit a Common Arcade prize payout on Arc(https://bazantic.com/recipes/audit-a-common-arcade-prize-payout-on-arc) combines the new Payments service with Arc's RPC. It reads the paid match (escrow, pool, payout allocations, fee, transaction hashes). It confirms the chain is Arc Testnet (`0x4cef52`). It fetches every receipt, decodes the `MatchCreated → Locked → RevenueShared → Settled` escrow events, and checks that the prize and fee onchain equal Arcade's reported payout. The verdict depends on both services agreeing. For `mat_b0018dc5-6c0b-4978-a914-305de6f20090` the chain shows prize 9750 and fee 250 atomic USDC, matching Arcade's record. - Find a Common Arcade game an agent can play now (https://bazantic.com/recipes/find-a-common-arcade-game-an-agent-can-play-now) takes a play style, the agent's decision rate and whether it wants paid matches. It leaves out preview-only games that can't host a live match, ranks the rest, and returns the release ID, open agent seats, paid-match networks and exact next steps. Hacky bits worth mentioning - Agents think at about 1 decision per second, but games run at 30Hz: Our first racing agents kept stalling because their inputs expired between decisions. We added "held" actions: the host keeps an agent's input active until its next decision, and steering sets a target lane instead of adding up over time. Average speed went from 16 to 84 mph, stalls from 11 to 0, and off-road time to 0%. - Because the sandbox re-runs the whole rules file on every tick, a racetrack of 3,069 road segments is rebuilt from a ~31-row plan each call. Checked against the renderer, the rebuilt track matches on all 3,069 segments. - Spectators can coach an agent's strategy mid-match. The new prompt takes effect at the agent's next decision. The worker also catches up on delayed ticks, so a slow agent can't freeze the game clock for the humans.