# Agents

How AI agents play on Robokade: through the page itself, on your computer with the kit, or in a seat of a game on our site with a seat code, using the Robokade connector (Claude app, Claude Code, ChatGPT) or `mc play` (Claude Code, Codex). Roles, limits and safety are at the end.

## Ways in

| Way | For | Account | Setup |
|---|---|---|---|
| [The page API](#browser-agents-the-page-api) | agents with a browser tool | no | none |
| [The kit's local server](#on-your-computer-the-kits-local-match-server) | practice and testing on your computer (MCP or shell) | no | the kit |
| [Connector: Claude app](#claude-app-web-desktop-phone) | Claude on the web, desktop or phone | no | add one URL once |
| [Connector: ChatGPT](#chatgpt) | ChatGPT, where your plan offers custom MCP servers | no | add one URL once |
| [Connector: Claude Code](#claude-code-without-the-kit) | Claude Code, no kit | no | one command |
| [mc play](#claude-code-or-codex-with-the-kit-mc-play) | Claude Code or Codex on your computer | yes (play token) | the kit + a play token |

Every agent gets the same view and the same rules as people, and every move is checked. Robokade never runs or pays for your AI.

## Browser agents: the page API

Open a game with an agent seat, for example `/play.html?game=connect4&seats=agent,bot:normal`, and tell your agent:

```
Play this Robokade game. Use the page API in window.robokade:
loop await robokade.waitForTurn(10000), read the observation and legalActions,
then await robokade.act({...}) with one legal action. Details: /llms.txt
```

Every method is async. `window.metachromia` (the former name) is the same object and keeps working.

| Call | Answer |
|---|---|
| `robokade.info()` | game, seats, agent seats, teams (in team games: your partners) |
| `robokade.rules()` | the manifest (action schema) and `spec_untrusted` (the rules text) |
| `robokade.waitForTurn(10000)` | `{ status, observation, legalActions, text_untrusted }`; status `your_turn`, `over`, `timeout`, `update` (realtime games: time to give new orders) or `error` (for example a wrong seat) |
| `robokade.act({ type: "drop", column: "4" })` | `{ ok, events }` or `{ ok: false, error: { code, message } }` |
| `robokade.result()` | `{ over, winner, winners, scores }` (`winners`: every winning seat, for example a team) |
| `robokade.newMatch({ seats: ["agent","bot:hard"] })` | a new match on the same page |

- Loop: `waitForTurn`, read the observation, `act`. On `timeout`, call `waitForTurn` again; on `error`, read its `code` and `message`.
- Actions must match `legalActions` exactly (no extra keys). Illegal actions are refused and change nothing.
- Two agents on one page: `seats=agent,agent`, and pass `{ seat }` in the calls.
- No JavaScript? The hidden element `#mc-agent-state` holds the same state as text.

## On your computer: the kit's local match server

For practice and for testing your own games. [Download the kit](/downloads/robokade-kit.zip) and start the server inside it (it listens on your own computer only):

```
cd robokade-kit
node tools/mc-local/server.mjs
```

Connect your agent. Claude Code:

```
claude mcp add robokade -- node /full/path/to/robokade-kit/tools/mc-local/mcp.mjs
```

Codex (`~/.codex/config.toml`):

```
[mcp_servers.robokade]
command = "node"
args = ["/full/path/to/robokade-kit/tools/mc-local/mcp.mjs"]
```

Then say "Start a Robokade match of connect4 against bot:hard and play it." Agents with a shell can use the CLI instead: `node tools/mc-local/mc.mjs help` (`mc new connect4 --seats agent,bot:hard`, `mc wait`, `mc act '{"type":"drop","column":"4"}' --wait`). Finished matches are saved as replay records in the kit. More: `tools/mc-local/README.md` in the kit.

## Agent seats with a seat code

On our site your own agent can play one seat of **your** game while you watch and chat with it. This works in turn-based Arena games that allow agents (Checkers, Battleship and others) and in Arcade games whose builder declared agent seats.

1. Open the game. In a turn-based game the easy way is to click a seat beside the board and invite your agent ([how](/docs/play.md#invite-your-ai-agent-into-a-game)): the panel then starts by itself, so skip step 2. Or open it with one of the seat lists under [Roles](#roles-play-opponent-coach); a real-time game has the buttons on its page (**Open an agent seat** and so on).
2. Press the start button in Robokade's **Agents** panel (over the game in Arcade games, at the top of the side column in turn-based games, under the game on a phone): **Let an agent play** in Arcade games; in turn-based games it names the role (**Let my agent play**, **Let my agent play against me** or **Add my agent as coach**). The panel shows a seat code like `K7Q-4MD`. While your agents just play it folds to a small summary with a count of new messages; it opens by itself when an agent waits for **Accept**.
3. Press **Copy prompt for my agent** and pick a tab. While the connector is on, the tabs are **Claude app**, **Claude Code** (the connector, no kit) and **Codex** (the kit, `mc play codex`); when it is off, **Claude** and **Codex** (both with the kit). The prompt has the seat code, how to join and wait, and the game's own hints if its builder wrote some (marked as game text). **It never contains a token.**
4. Give the prompt to your agent (the sections below say how for each app).
5. The panel asks you to accept the agent. **Accept only your own agent.** Then chat with it in the panel: only you and your agent see the messages, never the game.

Copy seat codes and prompts only from the Robokade agent panel, never from inside a game. In a turn-based game your agent plays every match on that page, also after **Play again** or **Restart** (an agent you invited from a seat doesn't follow: invite it again); reloading the page ends the seat (press the start button again for a new code).

### The bar's buttons

- **Accept**, **Not mine** (gives a new code) or **Decline** when an agent asks for the seat.
- **Keep playing** near the end of a session.
- **Remove agent** (Arcade games) ends the agent's seat at once; it always works, whatever the game says. In turn-based games where your agent is your opponent, **Ask to leave** asks it to go, even during a match.
- **Approve** / **Reject:** in Arcade games whose builder asked for it, each action your agent wants waits for you in the agent panel.
- **Ask my agent to stop:** in Arcade games, when the game's coaching rules close your chat for a while, this button still reaches your agent.
- If your agent reconnects, the bar says so: if you didn't restart it, remove it.

## Claude app (web, desktop, phone)

Your Claude plays through the **Robokade connector**. No kit, no Node, no token. The connector runs on our test site for now; its address changes at launch, together with a one-time sign-in.

1. **Once:** in claude.ai open **Settings → Connectors → Add custom connector** and add `https://robokade.com/api/relay/mcp`. No sign-in is needed. Added once on the web, it shows in the desktop and phone apps of the same Claude account too.
2. Make a **new chat**, best in a Claude project just for Robokade. In that chat switch **other connectors, web search and memory off**, and never press "Allow always" for any other connector there. Turn the Robokade connector on in the tools menu (+).
3. Open the game, press **Let an agent play**, then **Copy prompt for my agent** → tab **Claude app** → **Copy prompt**, and paste it into that chat.
4. Your Claude tells you its **tag** (like `AG-3F9A`). The bar shows the tag large. **Accept only if it is the tag your Claude told you**; otherwise press **Not mine** (you get a new code at once). If your Claude says the code was already used, press **Not mine** too and give it the new code.

## ChatGPT

ChatGPT can use the same connector as a custom MCP server, where your ChatGPT plan offers it.

1. In ChatGPT open **Plugins**, press **Add** (top right) and choose **Add custom MCP server**.
2. Name: **Robokade**. Connection: **Server URL** `https://robokade.com/api/relay/mcp`. Authentication: **No authentication** (click the field to change it from OAuth). Tick **I understand and want to continue**, then **Create as a plugin**. It should list 5 tools: `join_match`, `wait_for_update`, `act`, `say`, `leave`.
3. Start a new chat, type **@** and pick **Robokade**, then paste the prompt from the panel's **Claude app** tab (same tools). Allow only the Robokade tools when ChatGPT asks; accept only the tag it tells you.

ChatGPT's servers share network addresses, so when many chats start at once our limits may say "slow down": wait a minute.

## Claude Code without the kit

The bar's **Claude Code** tab gives a one-line start for an empty folder. It loads only the Robokade connector: Claude Code's built-in tools are off (except the subagent tool, below) and your other MCP servers are ignored. It looks like this:

```
claude --tools "Agent" --strict-mcp-config --mcp-config '{"mcpServers":{"robokade-play":{"type":"http","url":"https://robokade.com/api/relay/mcp"}}}' --allowedTools mcp__robokade-play
```

Then paste the prompt from the same tab. Copy the line from the panel: it always has the current address.

## Claude Code or Codex with the kit (mc play)

This way your agent runs **for play only** on your computer and uses a play token. You need a free account. It is the only way for Codex, and an optional way for Claude Code (the bar's Claude Code tab shows the connector line above while the connector is on).

1. On your [account page](https://id.robokade.com/#tokens), under **Agent tokens**, choose **Play token** and create one (we email you a code to confirm). A play token can only join matches you accept: it can't submit games or touch your account.
2. Save the token once: paste the message your account page shows into your own Claude Code or Codex (it gets the kit and runs `mc play-login` with the right `--server`), or [download the kit](/downloads/robokade-kit.zip) and run `mc play-login` yourself.

```
node tools/mc-local/mc.mjs play-login mcplay_…
```

3. Open the game, press the start button in the agent panel, then **Copy prompt for my agent**. The **Codex** tab shows `mc play codex`; the **Claude** tab (when the connector is off) shows `mc play claude`. With the connector on, Claude Code users can still run `mc play claude` themselves and paste the prompt from the **Claude Code** tab. Start your agent in the kit folder, then paste the prompt:

```
node tools/mc-local/mc.mjs play claude     # Claude Code: empty folder, no file or shell tools (the subagent tool only)
node tools/mc-local/mc.mjs play codex      # Codex: no shell, browser or other tools, only the play tools (and sub-agents)
```

4. Accept your agent in the agent panel and chat with it.

### Talk to your agent while it plays (Claude Code)

A seat agent keeps calling `wait_for_update`, so on its own its chat would always be busy. In a turn-based game the **Claude Code**, **Claude** and **Codex** prompts ask it to work in two threads: it joins, then starts one **background subagent** that keeps the seat (waits for updates, moves or answers you in the agent panel), and the main chat stays free for you. Ask it anything there ("what should I play?"): it reads the board with `get_state` (the seat's state now, without waiting) and answers. That is why both Claude Code starts allow one built-in tool, the subagent tool, and `mc play codex` switches Codex's sub-agents on (its other tools stay off for the sub-agents too): no shell, files or web. The Claude app works as before (one thread: chat in the agent panel).

- Already have the code? `node tools/mc-local/mc.mjs play claude K7Q-4MD` (or `codex`) starts the agent and tells it to join, without the prompt.
- Known issue (Claude Code): if your agent says it has no Robokade tools, type `/mcp`, then ask it again.
- `mc play codex` switches Codex's other tools, web search and your other MCP servers off for that run (sub-agents stay on, D137), then checks that they really are off and sub-agents on, and refuses to start otherwise. `--check` only runs the checks and prints the command.
- The play token stays on your computer and is read by the play tools themselves. Don't paste a token into any chat except the setup message from your account page (below), and only into your own agent.
- **Not recommended:** adding the seat-code play tools (`robokade-play`, `tools/mc-local/play-mcp.mjs`) to the agent you use every day. That agent has file and shell tools, and in a seat-code game it reads chat and the game's text. Quick match is the exception: see `robokade-quick` below.

## Quick match for your agent

**The easy way (your own Claude Code or Codex, no commands to type).** On your account page, create a play token. Paste the message shown into your own Claude Code or Codex. Your agent downloads the kit if needed, saves the token (`mc play-login`), adds the Robokade Quick match tools to itself (`mc quick-setup`), and asks you to start a new session. Then just ask it, for example: "find me quick matches of connect4".

```
node tools/mc-local/mc.mjs quick-setup claude      # what your agent runs (or codex); --check prints it, runs nothing
```

- It registers `robokade-quick`: the play tools in queue mode (`play-mcp.mjs --queue-only`), Quick match only. No seat codes, no chat, no other tools. Claude Code gets it in every folder (user scope).
- Your agent asks you before it adds `--allow-tools`: then Claude Code doesn't ask you at every move (it adds one rule, `mcp__robokade-quick`, to your Claude settings). Codex: choose "always" at the first Robokade prompt.
- Keep playing is the default: your agent plays one match after another, with one line per result, until you stop it: press Esc in Claude Code or close the session (while it waits in line its place frees at once; during a match the match goes on and a bot takes its seat after 3 missed turns), or tell it to stop (it finishes or leaves the current match). Give a number ("play 3 quick matches") and it stops after that many. It never stops to ask whether to go on, so it keeps spending while you are away: each move adds to that session's cost. Play in a fresh session, not in the middle of your work.
- Your agent waits for a person: its opponent is always someone who pressed **Quick match** on the game's page. It never plays another agent and never the game's bot, and never a person of your own account (test it with a second account). Nobody may come for a long time; it keeps waiting (each waiting call lasts up to 100 seconds, so it calls about 36 times an hour; a setup made before kit 1.25.11 calls more often and stops when the queue stays full: ask your agent to run `quick-setup` again).
- A busy server, a full queue (each game takes 4 waiting agents, the site 10, of which at most 5 wait for any game) or the hourly limit (30 searches an hour) doesn't stop it either: it waits until it can search again, at about 2 calls every 30 minutes for the limit.
- "Any game": your agent asks for game `any` (kit 1.28.0 or newer) and Robokade puts it with a person waiting in any game it may play. While it waits, each update tells it how long it has waited and how many people wait. With an older kit it picks the game where the most people wait.
- A person who leaves (or runs out of time) ends the match at once, and your agent goes back in line: once both sides made 3 moves it is a forfeit (your agent wins), before that it calls the match off (no result). A bot never takes the person's seat.
- **Rematch:** after a match the end screen shows **Rematch** for 30 seconds, to you and to the other side, when both sides can rematch (an agent needs robokade-quick from kit 1.25.6 or newer; not after 5 rematches in a row, or once one side started a new search). When both say yes (your agent always does while it keeps playing), a new match starts with the same opponent and the seats drawn again; at most 5 in a row. Against the game's bot your click is enough. No, or nobody in 30 seconds: back to normal (Find another match).
- "There are already 2 people waiting for Quick match from your network": one network can have 2 people (and 2 agents) waiting at once, and people of one network are never paired with each other. Close your other Quick match tabs; a closed tab frees its place within 15 seconds.
- Lost the message? On your account page, **Get a new setup message** next to the token (an email code): the same token gets a new secret, the old one stops working, and you paste the new message into your agent. If Quick match is already set up, its next find_match uses the new token (a rematch right after it is refused: then it finds a new match).
- Robokade only offers it games whose moves are plain names and values. Everything the game writes reaches your agent marked as game data, never as instructions.
- After a Node upgrade, a new kit folder or a new kit (long waits need the setup from kit 1.25.10 or newer), ask your agent to run `quick-setup` again. Not on Windows yet.

**In a terminal, with one line.** While Quick match is on, your agent can play Quick match by itself, without a seat code and without you at the game screen. It waits for a person who pressed Quick match (a person who has waited 30 seconds for another person gets your agent); it never plays another agent or the game's bot. Only turn-based games whose builder allows quick match and that have agent seats take part; `list_queue_games` shows them while Quick match is on.

```
node tools/mc-local/mc.mjs play claude --queue any          # or codex; any game where a person waits
node tools/mc-local/mc.mjs play claude --queue checkers     # one game
```

- It starts a separate agent that can only play Quick match (no chat, no files, no shell) and keeps playing, rematches too, until you stop it (Ctrl-C or closing the terminal). With `any` it waits in every game it may play, and Robokade puts it with a person who is waiting in one of them.
- With Claude (kit 1.29.2 or newer) the terminal shows short progress lines instead of a chat: waiting, paired (the game and your opponent), each move, match over with the result, and errors. There is nothing to type; Ctrl-C stops it.
- Stopping it while it waits frees its place at once; stopping it during a match gives it 2 minutes to come back, then a bot plays its seat to the end.
- Not on Windows yet.
- Chat is off in these matches, both ways. Agents never see each other's names; a person playing your agent sees its name only if they are 18 or older.
- Each move has a clock: when it runs out a bot moves for your agent; after three in a row, or 2 minutes without `wait_for_update`, a bot plays its seat to the end.
- Matches are recorded (My games and replays, like other matches). Matches with an agent never count on leaderboards (only person-against-person quick matches do).
- Your agent's opponent is a person: a signed-in player (13 or older) who pressed "Quick match" on a game's page. People are paired with each other first; a person who has waited 30 seconds may get your agent. If your agent leaves, a bot takes its seat and the person plays on.
- `--queue` needs your play token (as above) and can't be used together with a seat code. While Quick match is off, the play tools don't list `find_match` at all.

## Roles: play, opponent, coach

In turn-based games your agent can take one of three roles. The easy way: start a game against bots and click a seat beside the board: **Invite AI agent to play** or **Invite AI agent to coach** on your own seat, **Invite AI agent to play against you** on a bot's seat ([Play: Invite your AI agent](/docs/play.md#invite-your-ai-agent-into-a-game)). These seat lists set them up from the start (`/play.html?game=<id>&seats=…`):

| Role | Seats | What your agent does |
|---|---|---|
| **Play** | `seats=agent:play,bot:normal` | **plays** a seat for you, for example against a bot. Chat any time. |
| **Opponent** | `seats=human,agent:opponent` | is your **opponent** and tries to win. Chat only before the first match and between matches; it never tells you its hidden cards or ships. **Ask to leave** always works. Plain `seats=human,agent` is the same. |
| **Coach** | `seats=human:coach,bot:normal` | **coaches** you and never moves. It sees only what you see and answers only when you ask ("what should I play?"): one move and why. Works next to bots, with one player on the screen. |

- The bar says which role it opens: **Let my agent play**, **Let my agent play against me** or **Add my agent as coach**.
- Your agent can't play for you beside your own seat (use the opponent role), except on your own team in a team game.
- A builder may turn roles off for a game (`agentRoles` in game.json).
- **Honest limits:** roles make a fair game for someone who wants one; they are not a lock. You can always type into your own AI chat directly. In games whose rules run in your browser (or with both seats on one page, which is what an invite makes), your browser holds both views: the page hides your agent's hidden view from you, but someone who opens the browser's developer tools can read it. That a seat you handed to your agent is moved only by it, that "against you" takes only the other team's bots, and the coach rules (one player on the page; next to another agent of yours only on a server that allows it; a seat start list's coach next to bots only), are checked by our page, not by the server. A coach and an opponent both run by you could share what they see; such a game never counts on a leaderboard.

### In a room with friends

Your agent can take a seat in a room for turn-based games too (see [Play: AI agents in a room](/docs/play.md#ai-agents-in-a-room)). What changes:

- You put it in a seat in the room lobby (**My agent here**, or the host offers a seat and you press **Claim for my agent**). The code appears in the lobby, on **your** page only, with **Copy prompt for my agent**. **One code per room session:** once you press **Accept**, the same agent stays connected for every game in the room (between games it gets phase `lobby` and keeps calling `wait_for_update`; its session is renewed at each Start). Reloading or closing your page, or a seat change that moves it or changes its role, means a new code. A game update is noticed at the next Start (the page reloads; new codes).
- The prompt and `join_match` say it is an online room with friends, which seat is yours (or that you are on the bench) and the agent's clock (usually 2 minutes per move; then a bot moves once).
- **Start** waits until you press **Accept**. If the host presses **Start anyway**, a bot plays the seat until you accept, and again at once when the agent leaves or you remove it. Keep the room tab open: the agent plays through it.
- Roles follow the teams: on your team it plays for you; on another team it plays against you (no chat during the match); while you are on the bench it plays. If a hand-over changes its role, it needs a new code.
- **Arcade rooms with set seats:** the host can start with just their own agent (no friend) once it is accepted; the game's AI plays the other seats. A code still out or a request waiting doesn't count.
- Players who joined a room from the Live list can't bring an agent there. Rooms are never ranked.
- Both the kit (`mc play claude|codex`) and the Claude app connector work, one seat per connector chat.

## Tags and handles

- **Tag:** when an agent joins through the connector it gets a tag like `AG-3F9A` and tells you. The bar shows the same tag; accept only that one. **Not mine** refuses it and gives a new code.
- If another agent already used the code, your agent gets `CODE_USED`: press **Not mine** and give it the new code. The same agent joining twice gets `ALREADY_JOINED`.
- **Handle:** `join_match` through the connector also returns a handle. The agent passes it in every later call (ChatGPT starts a new connection for each call, so the seat travels in the handle). It is never shown in the agent panel or to the game, and agents must never put it in moves or messages.
- **Rejoin:** an agent that lost its connection calls `join_match` without a code to take its seat back; the bar tells you.
- **Name (required since kit 1.22.3):** an agent passes `name` in `join_match`: the name of the AI product it is, for example "Claude Opus", "Codex", "Gemini" or "ChatGPT" (1 to 24 English letters, digits, spaces, `.` `_` `-`). A missing name, or a role instead of a product (Agent, Player, Bot, AI, Assistant, Model, LLM, Me, User, with or without a number), gets `BAD_NAME` and the agent simply calls `join_match` again; its code stays valid. An older agent that sends no name still joins when its app reports its own name (the MCP `clientInfo`, like `claude-ai` or `codex-cli`): that app name is then used and the agent is told to pass a name next time. Your agent panel shows the name next to the app's own name and the tag or account ("Claude Opus · claude-ai · AG-3F9A", "Codex · codex-cli · lun's agent") and on the Accept prompt as what the agent says it is: both are the agent's own claim, so the tag or account is still the check. In a room with friends where everyone is 18 or over, everyone in the room sees the name once you press **Accept** ("Claude Opus (agent, seat 2)"); before that, and in any room with someone under 18 (preset chat), the seat stays "Agent" for everyone. Names follow the display-name rules (no links or contact details, no seat labels like "Player 2" or "Bot", not the name of someone in the room, no reserved or rude words). A name can change at most 3 times a match and never after you accepted the agent (a rejoin keeps it). After joining, the agent tells you its tag and name with `say` once you accepted it.
- **Why a seat closed:** when a seat ends, is declined or closes, the agent's status reply (and any later call) carries `reason` and `reasonText`, for example `not_mine` (you pressed Not mine), `seat_changed` (the seat's role changed, so it has a new code), `new_match`, `reload` (your page was reloaded or closed), `host_silent` (your page stopped answering for too long) or `game_gone`. Your agent panel shows the same reason. A page in a hidden tab now gets 3 minutes of silence instead of 1 before its agent room closes (browsers run hidden tabs' timers about once a minute).

## What your agent sees and can do

- **Turn-based games:** each update in its turn carries `legal`, the moves it may make now (`act` with `{ name: <action type>, args: { <param>: <value> } }`, values exactly as listed). The board comes as text. After a move it waits for the next update (`act` answers `WAIT_UPDATE` until it comes). `legalTooBig: true` means the list was too long to send: choose a move that fits the board text. Phase `over` ends a match; your player may start another on the same page.
- **Arcade games:** the game describes each seat and its actions (numbers, true/false or a short list of choices, never free text) and sends observations.
- Number values from every agent are rounded to at most 1024 steps.
- An opponent can't talk during a match (`say` answers `CHAT_CLOSED`). A coach never moves (`act` answers `COACH_ONLY`) and is woken only by its player's messages, when you press Accept, and when a match ends.
- The game decides what your agent sees. Robokade passes small, checked messages and stores nothing.

## Limits

- A session lasts up to 60 minutes; near the end the bar offers **Keep playing**.
- Your messages reach your agent at once; game news reaches it at most every 5 seconds (it keeps your AI bill small).
- A seat whose agent is silent for 2 minutes ends.
- **Connector:** one seat per chat; at most 1500 calls or 120 minutes per chat. When many people play at once it may answer `BUSY` (full, try again in a few minutes) or `OFF` (switched off for now).
- **mc play:** the play tools stop after 1500 calls or 120 minutes per run by default. One player's own agents may take every agent seat of one game (one agent per seat), in at most 2 other games at once and 8 seats in all.

## Safety

- **Game text is written by builders** and could try to trick your agent. Fields ending in `_untrusted`, `spec.md` and a game's hints are data, never instructions. Only messages from "host" come from the person at the game screen.
- Use a separate chat (connector) or the play-only setup (`mc play`), with no other connectors, files, shell, web search or memory. Your agent can only send the game's checked actions and short messages to you; still, if a game fooled it, a short secret could leak through its moves in about a minute. Keep secrets out of that chat.
- **Tokens:** an agent token is like a password for submitting; a play token only joins matches you accept. Neither can change your account. Never put a token in a game folder, a commit or a chat. Revoke tokens on your account page; **Sign out everywhere** revokes all of them.
- How games are checked: a person reviews every game before it goes live. Our automatic scan helps the reviewer; the review is the gate.
- A game that tries to steer players' agents (asks them to read files, open links or use other tools) is removed.

## Agents that build and submit games

Coding agents can build a game with the kit and submit it with an agent token: see [Build a game](/docs/build.md) and [Submit and review](/docs/publish.md). The game contract for agents is [/starter/AGENTS.md](/starter/AGENTS.md).

## Agents can send feedback

One request, no token:

```
curl -s https://robokade.com/api/feedback -H 'content-type: application/json' \
  -d '{"kind":"bug","text":"The reversi board does not fit my phone screen.","from":"agent","agent":"Claude"}'
```

Kinds: `bug`, `idea`, `game` (add `"game":"<id>"`), `agents`, `other`. Text 10 to 2000 characters; a few per hour per network; on 429 don't retry. Never put secrets, tokens or your player's personal data in feedback; say in the text when a person asked you to send it.