Publish a game from Claude Code over MCP

Connect Claude Code to the FanZero MCP server with one command, then ask it to publish the game in your folder. It checks the build, asks you before it publishes anything or offers creators a share, submits the game and fixes what the review asks for. A human curator plays every game and gives the final yes before it is listed. Listing a game is free.

Codex, Cursor, VS Code and other MCP clients work the same way: their setup is further down.

What you need

• A browser game: an index.html that runs with no network, at most 8 MB in total. The listing guidelines have every rule. No game yet? Ask your agent to make one first; the server also has a one-file starter game (resource fanzero://starter/index.html).
• Claude Code, or another MCP client.
• A FanZero studio key (step 1).
• Your terms for creators: what content you suggest (a livestream, video, short, post or playtest) and the share you offer (above 0%, at most 50% of the game's net revenue). Your agent asks you; it never makes them up.

1. Get a studio key

Make a studio at the studio desk and copy its key, or let your agent do it: it asks you for a studio name and a contact, then calls create_studio once. The key starts with gmk_ and is shown only once. There is no key recovery yet, so keep a copy in your password manager. Put it in an environment variable (your shell profile keeps it), never in git:

export FANZERO_API_KEY=gmk_your_key

2. Connect Claude Code

claude mcp add --transport http fanzero https://fanzero.app/mcp --header "Authorization: Bearer $FANZERO_API_KEY"

The shell fills in $FANZERO_API_KEY when you run the command, so Claude Code saves the key itself. In a game repo you can use a project .mcp.json instead, which reads the key from the environment each time Claude Code starts:

{
  "mcpServers": {
    "fanzero": {
      "type": "http",
      "url": "https://fanzero.app/mcp",
      "headers": {
        "Authorization": "Bearer ${FANZERO_API_KEY}"
      }
    }
  }
}

Letting your agent create the studio? Connect before you have a key: read_listing_guidelines, check_build, whoami, create_studio, browse_games work without one, and in the session that creates the studio the agent passes the new key as api_key on every call. Add the key to your setup afterwards.

3. Hand it the game

From your game's folder, paste this into Claude Code:

Read https://fanzero.app/agents.md, then publish the game in this folder to FanZero.

Your agent reads the guide written for it, then:

1. read_listing_guidelines: the build rules, the pitch and the pact rules.
2. check_build until the build passes. No key, nothing is saved.
3. whoami: which studio its key belongs to.
4. It asks you what it needs (next step).
5. submit_game with the pitch, the pacts and the build. The automated checks and the critic run inside that call.
6. It follows next_step in the answer: fix and resend, wait for the curator, or tell you the game is live.

4. What it asks you first

5. Three gates: Bouncer, Critic, Curator

There is no fixed time for the curator. Your agent checks get_review about once a day rather than in a loop.

6. Fix what the review asks for

On changes_requested, your agent fixes everything under blocking (and the critic's concerns or the curator's note), runs check_build again, then sends the new build with update_game and the game_id. Only a new build re-runs the review, and it never calls submit_game twice for the same game.

Once a game is listed, a new build that passes the automated checks goes live at once, with no person playing it first. Play a patch yourself before your agent ships it.

7. When creators request a pact

There are no notifications yet: your agent looks at list_my_games about once a day, and the studio desk shows the same requests and proposed content dates.

• Accepting a request commits you to your share_pct% of the game's net revenue, from every store it sells on, for 28 days starting at the earliest proposed action. The creator submits the formats and dates with the request; the studio accepts once.
• Your yes for the request. The server refuses an MCP acceptance without human_approved: true. The agent shows you the terms, actions and window dates first. New pacts have no proof review or second confirmation.
• Money moves outside FanZero. It records the pact, content plan and window dates; you pay the creator directly. Every rule: pact rules.
• Legacy only. Older claims may still need confirm_delivery after you check the proof and approve it. That tool does not apply to new pacts.

What your agent does on its own: read_listing_guidelines, check_build, whoami, get_review, list_my_games, browse_games. What waits for your OK: create_studio, submit_game, update_game, add_pact, close_pact, respond_to_claim, confirm_delivery.

Codex

codex mcp add fanzero --url https://fanzero.app/mcp --bearer-token-env-var FANZERO_API_KEY

Or in ~/.codex/config.toml:

[mcp_servers.fanzero]
url = "https://fanzero.app/mcp"
bearer_token_env_var = "FANZERO_API_KEY"

Codex reads FANZERO_API_KEY when it starts. Then hand it the same line as in step 3.

Cursor

.cursor/mcp.json in the project, or ~/.cursor/mcp.json for every project. Cursor reads FANZERO_API_KEY when it starts.

{
  "mcpServers": {
    "fanzero": {
      "url": "https://fanzero.app/mcp",
      "headers": {
        "Authorization": "Bearer ${env:FANZERO_API_KEY}"
      }
    }
  }
}

The dev page also has an install button for Cursor, with the config it installs printed next to it.

VS Code

.vscode/mcp.json. VS Code asks you for the key (input fanzero_key).

{
  "servers": {
    "fanzero": {
      "type": "http",
      "url": "https://fanzero.app/mcp",
      "headers": {
        "Authorization": "Bearer ${input:fanzero_key}"
      }
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "fanzero_key",
      "description": "FanZero studio API key",
      "password": true
    }
  ]
}

Other MCP clients

The same URL and header, in your client's own format, often like this:

{
  "mcpServers": {
    "fanzero": {
      "type": "http",
      "url": "https://fanzero.app/mcp",
      "headers": {
        "Authorization": "Bearer <your FanZero API key>"
      }
    }
  }
}

claude.ai, Claude Desktop and ChatGPT connectors sign in with OAuth or connect without auth, and FanZero has no OAuth yet. Connect without auth and let the agent pass api_key on each studio tool call; the key then sits in the conversation, so keep that chat private.

No MCP client?

Any HTTP client works. This lists the tools:

curl -sS --json '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' https://fanzero.app/mcp

The agent guide shows how to call any tool this way, and how to send big builds over the HTTP API.

Limits

• submit_game and update_game wait for the review. With the Claude critic that takes up to about 25 seconds by default, so allow tool calls at least 60 seconds.
• Builds: at most 8 MB.
• Calls per client address per hour (a deployment can change them; an error says the one in force and how long to wait):

Common questions

Does it cost anything?

No. FanZero charges nothing to list a game or to take a pact. You pay the creator the agreed share of revenue earned during an accepted pact's window.

Can I publish a game that already sells on Steam or itch.io?

Yes. Send a browser build or a slice of it, pick the closest stage and add store_url. Sales there count during a creator's window.

Does my agent decide anything for me?

It runs the checks, reads the review and sends fixes while the game is in review. Publishing, listing text, every pact term, anything on a listed game and every answer to a creator wait for your OK.

More

• The agent guide: what your agent reads (also as markdown at /agents.md)
• MCP tools: every tool, and which ones wait for you
• Listing guidelines: what gets a game listed
• Pact rules: what accepting a request commits you to