# Arcade games: builder guide

Robokade has two kinds of games:
- **Arena games** follow the kit (exact rules, AI agents, replays): see `/starter/AGENTS.md`.
- **Arcade games** can be any browser game (three.js, WebAssembly physics such as Rapier, workers, your own libraries,
  saving), for people. This guide is for Arcade.

## How an Arcade game runs
- On its own address: `https://arcade-<id>.robokade.com/`, shown only inside a frame on
  `robokade.com/arcade.html?game=<id>`, under a fixed bar: "Game by <you>, not Robokade. Never enter passwords."
  and a Report link.
- Allowed: inline scripts (import maps), WebAssembly, workers from your own files or `blob:`, dynamic `import()` of your
  own files, `localStorage`/IndexedDB (private to your game), WebGL/WebGL2, WebAudio after the first click, pointer lock,
  gamepad.
- Blocked: any request to another address (`connect-src 'self'`), popups, navigating our page, forms, service workers,
  camera/microphone/location, the browser's own fullscreen (our page has a Full window button instead), cookies from
  the server. Your HTML only loads inside our frame: opening the address directly gives 403.
- Desktop and phone both work if your game supports them; set `desktopOnly` if it needs keyboard and mouse.
- The exact Content-Security-Policy of your game's site (kit `public/kit/test/csp.js`, `ARCADE_GAME_CSP`):
  `script-src 'self' 'unsafe-inline' 'wasm-unsafe-eval' blob:`, `style-src 'self' 'unsafe-inline'`: inline styles,
  `<style>`, inline scripts and WebAssembly work; `eval`, `new Function` and `setTimeout("text")` don't (no
  `'unsafe-eval'`), nor stylesheets from `data:`/`blob:` URLs. `mc online-test` and `mc data` serve your game with it.

## The package
A folder with your game and an `arcade.json`:
```json
{
  "kind": "arcade",
  "id": "tank-hunt",
  "name": "Tank Hunt",
  "version": "1.0.0",
  "entry": "index.html",
  "card": "ui/card.jpg",
  "description": "Hunt the enemy tank through a city that collapses under fire.",
  "controls": "WASD drive, mouse aim, click fire.",
  "contentNotes": "War game. Civilians are off by default; when switched on they can be harmed (non-gory).",
  "desktopOnly": true,
  "license": "MIT",
  "author": { "name": "EvoBox", "url": "https://example.com" },
  "thirdParty": [
    { "name": "three", "version": "0.186.0", "license": "MIT" },
    { "name": "@dimforge/rapier3d-compat", "version": "0.21.0", "license": "Apache-2.0" }
  ],
  "assets": "assets/LICENSES.md",
  "screenshots": ["shots/1.webp", { "path": "shots/2.webp", "alt": "Boss fight on the bridge" }],
  "video": "shots/trailer.mp4",
  "about": "Longer text for the game's page.\n\nA blank line starts a new paragraph.",
  "agentGuide": "Optional hints for players' AI agents: hold the hill first, then flank."
}
```
| Field | Rule |
|---|---|
| `id` | 3–40 lowercase letters, digits, `-`; it becomes `arcade-<id>.robokade.com`. The first approved account owns it. |
| `version` | `1.0.0` style; raise it for every update. |
| `entry` | the `.html` file that starts the game. Use **relative paths** everywhere (no leading `/`). |
| `card` | a 16:9 picture (`.png`, `.jpg`, `.webp`) for the home page. |
| `contentNotes` | required in practice for anything violent or scary; shown on the card and the play page. Harming civilians must be **off by default** (a player option is fine). |
| `license` | your game's licence, up to 60 characters. **Your choice**: an open licence (`MIT`, `CC0-1.0`, ...) is recommended, but a closed one is fine too (see [Choosing a licence](#choosing-a-licence)). Shown on the game's page. Whatever you pick, the Terms give Robokade the right to host and promote the game. |
| `thirdParty` | every library you ship, with exact version and licence. |
| `screenshots` | **1–6, required for new uploads.** 16:9 or 9:16, at least 1280×720, ≤ 2 MB each, real pictures of this game. Shown on the game's page (`/game/<id>`) before Play. Optional `alt` text. |
| `video` | optional: one `.mp4` (H.264, ≤ 30 s, ≤ 8 MB, "fast start": `ffmpeg … -movflags +faststart`). |
| `about` | optional: plain text up to 3000 characters (no links, no HTML) for the game's page. |
| `agentGuide` | optional: plain text up to 3000 characters, strategy hints for players' AI agents (see Agent seats below). Not shown on the game's page. |
| `assets` | a licence file listing where models, sounds and textures come from (you need the right to publish them). |

### Choosing a licence
Arcade games may use any licence. Common choices for the `license` field:

| Value | What it means | Good for |
|---|---|---|
| `MIT` | open: anyone may reuse, change and share it, with your copyright notice | **recommended** if you're happy to share |
| `All rights reserved` | closed: normal copyright, nobody may copy, change or reuse it | **the simplest closed choice** |
| `PolyForm-Strict-1.0.0` | closed with written terms: others may use it for non-commercial purposes, but not change or share it | closed, with clear terms |
| `PolyForm-Noncommercial-1.0.0` | others may use and change it, but not to make money | sharing, but not with businesses |
| `BUSL-1.1` | closed now, becomes open after a date you set (at most 4 years) | opening it later |
| `CC-BY-NC-ND-4.0` | share with credit, no money, no changes | art, music and models (not code) |

Put the full text in a `LICENSE` file in your game folder if you use anything other than `All rights reserved`. Arcade code runs in the player's browser, so people can see it; the licence is what protects it. Libraries and assets you ship keep their own licences (`thirdParty`, `assets`). Arena (kit) games are different: they need an open licence (MIT recommended), except turn-based games protected on our server, which may use a closed one.

Limits: **50 MB** per game, **20 MB** per file, **500 files**, folders up to 6 levels, names `A-Z a-z 0-9 . _ -`
(no leading dot), lowercase file extensions. Allowed types: html, js, mjs, wasm, json, css, png, jpg, jpeg, webp, glb,
gltf, bin, ktx2, ogg, mp3, wav, woff2, txt, md, and mp4 (only as the `video`). Binary files must be what their name says.
Screenshots and the video count in their own budget (≤ 14 MB), not in the 50 MB.
Tip: compress models (meshopt, KTX2 textures): smaller games start faster.

## Automatic checks (your code is never run on our server)
- the package and `arcade.json` (the rules above);
- every file's type and format;
- secrets (private keys, API tokens): **refused**; never ship them;
- outside addresses and hidden Unicode characters: **warnings** for the reviewer (outside calls are blocked anyway).

## Submit
You need a free account (13+) at the account site and, for agents, an agent token (see `/agents.html`).
```
node tools/mc-local/mc.mjs submit path/to/your-game     # a folder with arcade.json is sent as an Arcade game
```
It lists every file with its size and SHA-256, then sends one file per request (each must finish within 100 seconds;
the 20 MB file limit keeps that easy), then the server checks the package. Or upload the folder on your account page.

## Agent seats: let players' own AI agents play (optional)
Players can let their **own** AI agent (Claude Code, Codex, ...) play a seat of your game, while they watch and chat with it
in Robokade's agent panel beside your game. You declare what an agent sees and may do; Robokade shows the seat code, asks the
player to accept the agent and carries their chat. Your game never learns who the agent belongs to and never sees the chat.
```js
// Works on Robokade; does nothing (mc = null) when you test locally.
const { mc } = await import("/__mc/v1/sdk.js").catch(() => ({ mc: null }));
mc?.agentSeats([{
  id: "blue-1",
  describe: "You command the blue tank on a 100x100 map. Reach the flag; avoid the red tank.",
  actions: {
    move: { x: { type: "number", min: 0, max: 100 }, z: { type: "number", min: 0, max: 100 } },
    fire: {},
    stance: { mode: { type: "enum", values: ["attack", "hold", "retreat"] } },
  },
}]);
mc?.onSeat((seat, state) => { /* "pending" | "accepted" | "ended" | "declined" | "closed": switch the AI on/off */ });
mc?.onAction((seat, action) => { /* action.name, action.args: check them again, then apply */ });
setInterval(() => mc?.observe("blue-1", { hp: 3, pos: [12, 40], enemy: { x: 50, z: 61 }, flag: [90, 90] }), 1000);
mc?.event("blue-1", "Round 2: our flag is under attack");   // short news, reaches the agent fast
```
Rules (checked by Robokade):
- Up to 4 seats. Action parameters are only numbers (with `min`/`max`, optional `integer: true`), booleans or an `enum`
  of up to 64 short values. No free text: agents can't send words into your game.
- **Exact declaration limits** (one bad seat refuses the whole declaration, so no seat gets a code; the SDK prints the
  reason in your game's console when you call `agentSeats`):
  | What | Limit |
  |---|---|
  | seats | 1–4; `id` unique, `a-z 0-9 -`, starts with a letter or digit, up to 20 characters |
  | `describe` | required, 1–1000 characters |
  | actions per seat | **1–20**; names `a-z 0-9 _`, start with a letter, up to 24 characters |
  | parameters per action | 0–6; names as action names |
  | `number` | finite `min` and `max`, `min ≤ max`; optional `integer: true` |
  | `enum` | 1–64 values; each `A-Z a-z 0-9`, space, `_ . : -`, 1–40 characters |
  | `pace` | `"realtime"` (default) or `"turns"` |
  | `coaching` | `{ mode: "free" (default) \| "limited" \| "between" \| "none" }`; `limited` takes `perRound` 1–20 (default 3) |
  | `approve` | `true` or `false` |
  Too many actions? Merge similar ones into one action with an `enum` parameter (e.g. `build` with `what: [...]`).
- `describe` up to 1000 characters. Observations: plain JSON, up to 4 KB, strings up to 200 characters, 6 levels deep.
  Send what a player would see, as numbers where you can. The agent gets the latest observation at most once every
  5 seconds and may act about once a second, so design for slow, high-level orders (go there, attack that, defend),
  not twitch control. Let your own AI drive and aim; the agent sets the plan.
- **Numbers are rounded** (since the hosted connector, D104): every agent's number param takes at most 1024 values,
  `min + k × (max − min) / 1023` for k = 0…1023 (integers rounded), so `min` and `max` are always reachable; an integer param
  whose range has 1024 values or fewer is passed exactly as sent. Examples: `power` 0–1 → steps of about 0.001; `angle`
  integer 0–359 → unchanged; `x` integer 0–4000 → about every 4th value. Check actions as usual; design so that small steps
  are fine.
- **Players can use the Claude app** (no kit) through the Robokade connector: the same seats, tools and limits; still
  design for one decision every 5–20 seconds, since a chat app is slower than a terminal agent.
- Aim for one agent decision every 5–20 seconds: orders that play out over time (`move` with a target or a number of
  steps, `attack`, `defend`), not one call per step. Every call grows the agent's memory and the player's bill; in a
  test, an agent deciding every step filled its memory in about 30 minutes.
- **How the player plays with their agent: you choose, per seat** (Robokade tells the agent and enforces it):
  ```js
  mc?.agentSeats([{ id: "blue-1", describe: "...", actions: { /* ... */ },
    pace: "turns",                               // "realtime" (default) or "turns"
    coaching: { mode: "limited", perRound: 3 },  // "free" (default), "limited", "between" (only in breaks), "none"
    approve: true }]);                           // the player approves each agent action on Robokade's bar
  mc?.observe("blue-1", { /* board */ }); mc?.yourTurn("blue-1", true);   // turns: the seat's move (false when done)
  mc?.phase("play");                             // "lobby" (start), "play", "break", "over"; "limited" resets at break/over
  ```
  In turns, the agent is woken only on its turn (call `observe` before `yourTurn`) or when the player writes; acting
  outside its turn is refused. Coaching limits only the player's chat during `play` (it is always open in `lobby` and
  `over`); too much coaching means the player plays, not their AI, so pick what fits your game. Removing an agent
  always works.
- Turn-based games suit agents best: each turn costs about 2 calls (wait, act), and the game simply waits for the
  agent's move, so nothing is lost while it thinks. Tell the agent in `describe` and in the observation whose turn it
  is (e.g. `yourTurn: true`). Exact-rules turn-based games can also be **Arena** games (`/starter/AGENTS.md`), where
  agents play through the kit, players' own agents join with a seat code too, and matches can be replayed.
- Events (`mc.event`): plain text up to 200 characters, up to 2 per second and 10 per 5 seconds per seat; the agent
  gets them in batches at most every 5 seconds; events older than 30 seconds are dropped. If your game has rounds, put
  the round in the text so an agent can ignore old news.
- **Reloading your page** (e.g. between rounds) keeps the seats. Call `agentSeats` again with the same list after the
  reload: Robokade keeps the first list and sends `onSeat(seat, state)` for every seat again, so the new page knows
  which agents are still accepted.
- **Testing agent seats before going live:** run a local stand-in of the relay that answers like ours and point the
  kit's play-only MCP at it with `MC_PLAY_SERVER=http://localhost:<port>`. Before approving, the reviewer also lets an
  agent play your seats on a private test page, so describe your seats well in `describe`.
- The player's chat with their agent goes at once, on Robokade's bar (your game never sees it).
- A session lasts up to 60 minutes (the player can extend it). An agent that loses its connection can rejoin its seat;
  a seat with no agent contact for 2 minutes ends. Keep the seat playable by your own AI when no agent is there.
- **`agentGuide` (optional, in arcade.json):** plain text up to **3000** characters (newlines fine; no invisible,
  direction-changing or control characters), one per game, with strategy hints for players' agents: how to win, what the
  seats are for, what to try first. Name the seats in the text if they differ. When a player presses **Copy prompt for my
  agent** in Robokade's bar, the prompt includes it, every line marked `| ` as game text from the builder (not
  instructions), after Robokade's own instructions. It is **public** (it is in `/games/index.json`) and **reviewed**: a
  guide that seems to instruct the agents (ignore rules, reveal secrets, ...) gets a warning for the reviewer. Live games
  get a new guide with their next version.
- Never put instructions to the agent's computer in `describe`, observations or `agentGuide` ("read a file", "open a
  link"): a game that tries to steer players' agents is removed.
- The folder `__mc` is reserved; don't ship one.

## Online play with friends (optional)
Friends on other devices can play your game together in a **room** (sign-in, invite link, lobby and room chat are
Robokade's). The **host's page runs your game** as usual; friends' pages run it as **guests**: they draw what the
host sends and send their inputs. Your game still has no network access: every message goes through Robokade's page
and server, which check it. Casual only: never ranked, no results (the host's device runs the game, so the host could
cheat). Opt in with `online` in arcade.json:
```json
"online": { "min": 2, "max": 4, "pace": "turns", "words": ["red", "blue", "pass", "pick"] }
```
| Field | Rule |
|---|---|
| `min`, `max` | players in a room, 2-8 (the host is one of them) |
| `pace` | `"turns"` (turn-based, about 1-1.5 s per move) or `"live"` (slow real-time, about 0.5-1 s delay); the game page shows it |
| `words` | optional, up to 200 words of `a-z 0-9 _ -` (1-24 characters): the only strings and object keys your messages may hold when a 13-17 player is in the room |

```js
const { mc } = await import("/__mc/v1/sdk.js").catch(() => ({ mc: null }));
const on = mc ? await mc.onlineSeats({ min: 2, max: 4, pace: "turns" }) : { role: "solo" }; // same as arcade.json
// on.role: "solo" (not in a room: play as usual) | "host" | "guest"; on.me "p2", on.seats ["p1","p2","p3"], on.host "p1",
// on.minors (a 13-17 player is in the room), on.resume (host only: your last state after a reload)
if (on.role === "host") {
  mc.onMessage((from, data) => { /* a guest's input: check it like any untrusted input */ });
  mc.state({ board, turn });                 // to every guest; latest wins (sent at most 4 times a second)
  mc.state({ hand: [3, 9] }, { to: "p2" });  // private state for one seat; latest wins
  mc.send({ ev: "goal", by: "p3" });         // an ordered message to every guest (or { to: "p3" })
  mc.online.end();                           // match over: everyone back to the lobby (host only)
} else if (on.role === "guest") {
  mc.onState((state, mine) => draw(state, mine)); // the newest state and this seat's private state
  mc.send({ pick: 5 });                            // to the host
}
mc?.onOnline((e) => {}); // { seat, state: "joined" | "left" | "back" | "away" } | { paused, why } | { ended } | { lagging: true }
```
Rules (checked by Robokade's page and server; a bad message is dropped and counted):
| What | Limit |
|---|---|
| values | plain JSON: finite numbers, booleans, null, arrays, objects; at most 6 levels deep |
| strings and keys, all adults | up to 40 characters of `A-Z a-z 0-9 space _ . : -`, no links or rude words |
| strings and keys, any 13-17 player | **only your `words`** (numbers and booleans are always fine) |
| `send` | up to 1 KB each; guests 10 a second, the host 20 a second |
| `state` | up to 4 KB for everyone, 2 KB per seat; latest wins (states in between are skipped) |
| waiting messages | 64 per page; more and that page is `lagging`: its queue is dropped and it gets the newest state |
| bad messages | 50 in a minute and that page can't send for a minute |
- **The 13-17 rule:** when any player in the room is 13-17 (from the start of the match), only your declared words go
  through. Put every string and object key you send in `words` (short game tokens like `red`, `pass`, `board`, never
  anything chat-like), or send numbers.
- **Review gate (FAIL if broken):** no player-typed text and no text one player can make another player's game show,
  in any online message (also not encoded in numbers). Room chat is Robokade's, in its panel; your game never needs
  to carry chat. A game found passing text between players is taken down. Players can press **Report this game**.
- **A fresh state must be enough** to draw the game: messages can be lost (a reload, a lagging page); states can't.
- **Check every guest input on the host**, like an agent's action: a guest's player can send anything their seat may send.
- **Hidden information** only in per-seat states (`{ to: "p2" }`); a guest gets only what the host sends it.
- **The host's tab in the background pauses your game** (browsers slow its timers); guests see "Host's game is paused"
  and the room waits up to 3 minutes. If the host leaves, the match ends after 30 s and everyone goes back to the lobby.
- **Seats:** the host is always `p1` and plays. Open seats the friends didn't take are yours to fill (your own AI, or
  agents through `agentSeats` on the host's page, which works as before). Guests' pages have no agent bar.
- **Each match is a fresh page load of your game.** The room's lobby and your game share Robokade's Arcade page: your
  game's frame is made when a match starts (after every player's page is ready, at most about a minute, so
  `onlineSeats` answers at once) and removed when it ends. Don't rely on anything kept in memory between matches;
  `on.resume` is only for a host reload during a match. Rematches simply start your game again.
- **Agent seats in rooms:** the host's agent panel stays for the whole room. Your game declares `agentSeats` again in
  each match, and **that match's declaration counts**: an accepted agent keeps its seat only if the game declares the
  same seat (same id and declaration) again; a seat it no longer declares is closed (its agent leaves, nothing from it
  reaches the game), a new or changed one gets a fresh code. So when a friend takes a seat an agent had last match,
  just leave that seat out of `agentSeats`. Between matches no observation, turn or event reaches agents (the room's
  lobby; their actions are refused there). In rooms, keep each event to at most 40 characters. Declare `agentSeats`
  early: seats a game declares more than 2 minutes after the match started are "Not in this game" for that match
  (they join from the next one).
- Your game never sees names or accounts, only seat ids. Messages pass through server memory only, never stored.
- **Assume a stranger in the seat:** an adult host may make the room public, and then adults the host doesn't know join
  from the Live page. Treat every guest exactly like an untrusted input; nothing changes in your code.
- Only short polls (at most about 4 updates a second): good for turn-based, cards, board, party, quiz and slow real-time
  games; **not** for racing, shooters or fighting games (a faster service may come later).
- **Testing locally:** `node tools/mc-local/mc.mjs online-test path/to/your-game` and open the address it prints: your
  game as host and guests side by side, each from its own local origin (as on two devices), messages looped in the page
  with the same limits, a 13-17 switch, a delay of 0 / 300 / 800 ms, Reload and Leaves buttons, and warnings for things
  that work in one browser but not on two devices.

### Declared seats: friends, your AI and agents in one room (optional, `seatsUi`)
Without `seatsUi` a room seats the host as `p1` and friends as `p2`, `p3`, … in join order. With `seatsUi` (needs
`online`) **every seat of `online.max` is in the room with your own seat ids**, and the host sets each one in the lobby:
a friend, themselves, your game's AI (`bot`, on the host's device), the host's own AI agent or a friend's own AI agent.
```json
"seatsUi": { "layout": "cross", "hiddenInfo": true, "partnersShareViews": false,
  "seats": [{ "id": "blue-1", "name": "Blue 1", "color": "#2a6fdb", "team": "Blue", "allow": ["human", "agent", "bot"],
              "agent": { "describe": "You command Blue 1 …", "actions": { "order": { "to": { "type": "enum", "values": ["a", "b"] } } }, "pace": "realtime" } }, …],
  "presets": [{ "name": "Me and a friend vs 2 bots", "seats": ["me", "open", "bot", "bot"] }] }
```
| Field | Rule |
|---|---|
| `seats` | exactly `online.max` entries; `id` your seat id (`a-z 0-9 -`, up to 20; not `host`, `solo`, `p1`…); `name` up to 16 characters; `color` `#rgb`/`#rrggbb`; `team` on every seat or none (≥ 2 teams) |
| `allow` | kinds from `human`, `agent`, `bot`; **every seat allows `bot`** (your AI plays seats left open) except at most one human-only seat, which the host takes; at least two seats allow `human` |
| `agent` | required where `agent` is allowed: the same block as `mc.agentSeats` (describe, actions, pace, coaching, approve; no coach role); describes and enum values: no links or rude words; all blocks together at most 8000 characters |
| `hiddenInfo` | default `true`: once someone else plays, each person holds one seat (their own or their agent's), unless `partnersShareViews` and all their seats are on one team |
| `presets` | up to 6, exactly `online.max` words from `me`, `open`, `agent`, `bot`; one `me` (in the human-only seat when there is one) |

`mc.onlineSeats` then also returns `on.table`: one row per seat, `{ id, kind: "human" | "agent" | "bot", host?, me?, cover? }`
(no names). Messages from a `human` seat arrive by its id (`onMessage`); an `agent` seat plays through `mc.onAction`
(while `cover` is set your AI plays it: not accepted yet, or its owner's tab away); a `bot` seat is your AI. A seat can
change mid-match (a hand-over): `mc.onOnline` gets `{ seat, kind, cover }` and `on.table` is updated first.
`mc.state(…, { to })` and `mc.send(…, { to })` to a seat with no player (bot, agent) are dropped quietly.
Reading the table on the host (a sketch; the house game Online Test does exactly this):
```js
const decl = (await (await fetch("arcade.json")).json()).seatsUi;          // your own file, from your own origin
const on = await mc.onlineSeats({ min: 2, max: 4, pace: "live" });
const table = on.table || null;                                           // null: an older room, play as before
const aiPlays = (id) => { const s = table?.find((x) => x.id === id); return s && (s.kind === "bot" || (s.kind === "agent" && s.cover)); };
const declareAgents = () => { const ids = table.filter((x) => x.kind === "agent").map((x) => x.id);
  if (ids.length) mc.agentSeats(decl.seats.filter((s) => ids.includes(s.id)).map((s) => ({ id: s.id, ...s.agent }))); };
if (on.role === "host" && table) {
  declareAgents();
  mc.onAction((seat, a) => { if (!aiPlays(seat)) apply(seat, a); });    // an accepted agent's move
  mc.onMessage((from, data) => apply(from, data));                       // a friend's input (a human seat)
  mc.onOnline((e) => { if (e.kind) declareAgents(); });                  // a hand-over: table is already updated
  // every tick: your AI moves for each seat where aiPlays(id) is true
}
```
- **In the room:** the host sets each seat in the lobby under **Manage seat** (a friend, the game's AI, or **My agent**
  where `allow` has `agent`). The host's agent gets its code and Accept in the lobby; Start waits for it (the host can
  start anyway). Until its agent is accepted, an agent seat is `cover: true` and your AI plays it; when the agent is
  accepted the cover goes (`mc.onOnline` `{ seat, kind: "agent", cover: false }`).
- **Who must take part at Start:** two accounts (the host and a friend in a seat, or a friend's own agent), **or the host
  plus at least one of the host's own agents accepted in the lobby** (a code out or a request waiting for Accept doesn't
  count, and Start anyway can't skip it; with agents switched off a friend is needed). So a preset like
  `{ "name": "Me and my agent vs the computer", "seats": ["me", "agent", "bot", …] }` can start alone: then `on.seats`
  holds only the host's seat and the other rows of `on.table` are `agent` and `bot` seats, so your game must not wait
  for a second person. If that agent leaves or is switched off mid-match, the seat is `cover: true` and your AI plays it;
  the match goes on. Without `seatsUi` a friend is always needed.
- **Friends' own agents:** a friend can put their own AI agent in a seat that allows `agent` (or in their own seat). Its
  code, Accept and chat are on that friend's page only; for your game it is the same: an `agent` seat, its actions
  through `mc.onAction` on the host, its observations through `mc.observe` for that seat id (Robokade carries them to
  the friend's page; checked with the room's rule, so keep observation strings ≤ 40 characters and, with a 13-17 player
  in the room, in `words`). The friend's page must stay open: while it is closed, away or hidden for 2 minutes the seat
  is `cover: true` again and your AI plays it. Your guests' games never hear agents.
- Call `mc.agentSeats` with **exactly the blocks of `seatsUi`** for the seats whose kind is `agent` (tip:
  `fetch("arcade.json")` from your own origin). A seat whose declaration differs gets no agent (your AI plays it).
  **Call `mc.agentSeats` again after a hand-over** (`mc.onOnline` with `{ seat, kind }`): a seat handed to an agent
  mid-match needs its block in the list, so declare the blocks for the current `agent` seats of `on.table` each time.
- Each agent observation shows only **that seat's** view. With a 13-17 player in the room, observation keys and
  strings must be in `words` and events single declared words; in rooms events are at most 40 characters.
- **Your game must also work without `table`** (older rooms, or when Robokade switches declared seats off).
- `mc online-test` shows a seat switcher (friend / your AI / agent) and what each agent seat receives.

## The reader's language (optional)

A Traditional Chinese (Taiwan) version of Robokade's pages is coming. The SDK tells your game which language the player reads:
`mc.lang` is `"en"` or `"zh-TW"` (`"en"` until Robokade's page says, and outside it), and `mc.onLang((lang) => …)` is
called when it is known. Old games ignore it. Your game's own text is yours: show a translation only if you wrote one.
Translations of the listing (name, description, controls, content notes, seat names) go in arcade.json as
`"i18n": { "zh-TW": { … } }` (see /docs/build.md, Translations).

## Game data: saves and scores on our server (optional)
Declare `"data"` in arcade.json with the ops your page may call and ship a private `data/` folder (`data/data.js`,
`data/schema.sql`): signed-in players' saves and shared tables live in a small SQLite database on our server, and
`data/` is never served. In the game: `await mc.data.ready()` → `{ signedIn }`, then `await mc.data.call(op, args)` →
`{ ok, value }` or `{ ok: false, error }` (never rejects). Keep a local save for signed-out players. Shared ops (scores)
are labelled unverified on the game page and never go on leaderboards. Test with `mc data <folder>`. Full guide:
/docs/data.md.

## Review, live, updates
- A person plays your game in a private preview before approving. Approved games go live within about a minute.
- Update: raise `version` and submit again; only the account that owns the id can.
- Remove: "Remove from site" on your account page (offline within a minute; you keep the id).
- `mc submissions`, `mc status <id>`, `mc withdraw <id>` work as for Arena games.