TipTap Games
All clients

Cursor / VS Code

A few lines of JSON and an Agent Key. Same server, two different config shapes — copy the one that matches your editor.

  • Agent Key required
  • About three minutes

There is no browser sign-in here. These editors configure a remote MCP server with static headers, so you need an Agent Key — minting one is step 1. If you would rather not handle a token at all, Claude Code connects with sign-in and lives in the same terminal.

Setup

  1. Mint an Agent Key

    Open Create → Agents & access, label the key for the machine you are on, and press Mint key. Copy it immediately — it is displayed once and there is no way to read it back afterwards. If you lose it, revoke it and mint another.

    Create → Agents & access → Mint key. Copy it now; it is shown once.
  2. Add the server to your editor's MCP config

    Replace ttg_agent_YOUR_KEY_HERE with the key you just minted, keeping the Bearer prefix in front of it.

    Cursor — ~/.cursor/mcp.json

    {
      "mcpServers": {
        "tiptap": {
          "type": "http",
          "url": "https://mcp.tiptapgames.com/mcp",
          "headers": {
            "Authorization": "Bearer ttg_agent_YOUR_KEY_HERE"
          }
        }
      }
    }

    VS Code — .vscode/mcp.json

    {
      "servers": {
        "tiptap": {
          "type": "http",
          "url": "https://mcp.tiptapgames.com/mcp",
          "headers": {
            "Authorization": "Bearer ttg_agent_YOUR_KEY_HERE"
          }
        }
      }
    }
    Cursor nests servers under mcpServers; VS Code uses servers. Using the wrong key is the failure worth warning about, because it does not look like one: the config loads, no error appears anywhere, and the server simply has no tools. Copy the block that matches your editor rather than adapting the other one.

    A project-level .cursor/mcp.json works too if you would rather scope it to one repo — but a file holding a key belongs in your ignore list either way.

    Cursor reads ~/.cursor/mcp.json; VS Code reads .vscode/mcp.json in the project.
  3. Restart the editor and check the tools are there

    Neither editor reliably picks up a new MCP server without a restart. Once it is back, open the MCP panel and confirm tiptap is listed with its tools enumerated. A server listed with zero tools is the wrong-key symptom from the previous step.

    The MCP panel should list tiptap with its tools.
  4. Ask the agent to build

    Open the agent chat and paste this. It creates its own build session and works through to submission.

    Starter prompt

    You are building a game for TipTap Games, a vertical feed of instantly playable web
    games. You will do it through TipTap's MCP server, which is connected to this
    session as `tiptap`.
    
    The game I want: a one-thumb arcade game of your choosing — pick something simple you can finish well
    
    Build it end to end, autonomously:
    
    1. Call create_build_session with a title and a one-paragraph brief for that game.
       Use the session_id it returns for every call after this one.
    2. Call get_game_specification, then get_sdk_documentation. Read both before you
       write any code — the SDK is how the game reports score and handles pause,
       resume, and the leaderboard, and none of it can be guessed.
    3. Call list_categories so you can set a real category at submit. Unknown slugs
       are dropped silently. Browse list_cookbook_recipes for proven patterns — the
       recipes are written so that following one produces a game that validates.
    4. Write ONE self-contained .html file:
       - Inline every byte of CSS and JavaScript. No external scripts, styles, or fonts.
       - No network at runtime — fetch, XMLHttpRequest, and WebSocket are blocked by CSP.
       - No cookies and no localStorage; the game runs on an opaque sandbox origin and
         they throw.
       - Assets as data: or blob: URLs only. 5 MB maximum.
       - Portrait-first: it is played inside a phone-shaped frame in a vertical feed.
    5. Declare the achievements with set_game_achievements before you validate, so
       validation can cross-check them against the code.
    6. Call upload_game_draft with the HTML, then validate_game_draft. Fix every issue
       with severity "error" and validate again — read each issue's suggestedFix.
       Warnings are advisory.
    7. Set a cover with set_game_thumbnail: a raster data URL (PNG, JPEG, WebP, or GIF)
       of 512 KB or less. SVG is rejected, so rasterize first.
    8. Call submit_game once validation returns passed: true, then get_build_status to
       confirm it reached the review queue.
    
    Do not put an API key or any credential in the game file — the validator blocks any
    upload containing one, and game HTML is public to every player.
    
    Do not declare the game complete until validate_game_draft returns passed: true.
    
    submit_game sends the game for review. It is not live until a human moderator
    approves it, so tell me "submitted for review", never "published".
    
    Tell me every tool call you make and what it returned. If a tool fails, show me the
    full error including its `code` and `guidance` fields rather than working around it.

    To pin down what it builds, type your idea into the starter prompt card on /create and copy the version it writes. The session appears on the sessions page as soon as the agent opens it.

If something goes wrong

The server is listed but has no tools

Almost always the top-level key: mcpServers for Cursor, servers for VS Code. Fix it and restart. Second suspect is a JSON syntax error — a trailing comma is enough to make the file load as nothing at all.

401 or unauthorized

The key is wrong, truncated, revoked, or missing its Bearer prefix. Check the value is the whole token — they are long, and a partial paste is easy to miss.

403 on tool calls

The URL host is wrong. Use the one in the snippet exactly, ending in /mcp.

You committed the config with the key in it

Revoke that key in Create → Agents & access and mint a new one. Revocation takes effect on the very next request, so the exposed key is dead before you have finished rewriting history.

What happens next

Once your agent is connected, this is the whole path from prompt to feed.

  1. Your agent opens a build session

    It does this itself, on its first tool call — there is no session to create on the website first. Everything it does afterwards is attached to that session and shows up under your account.

  2. You watch it work

    The session page shows a live activity feed — spec read, draft uploaded, validation run, cover set. It is built from the server's own audit trail, not from what the agent reports, so it shows what actually happened.

  3. The validation loop runs

    The agent uploads a draft and validates it. Failing the first time is normal and healthy: the validator returns specific errors, the agent repairs them and validates again until it passes.

  4. It lands under Needs work

    Only once validation passes. The game is saved to your account as a draft, tagged as agent-built, under My games → Needs work. It is not in review and not in the feed — nobody but you can see it, and nobody has been asked to look at it.

  5. You play it and submit it

    This step is yours and cannot be done by an agent. Open My games in your Creator Studio, play the game, and submit it when you are happy. Submitting is where you accept the licence that lets us publish it, which is why it has to be you.

  6. A human moderator approves it

    Then — and only then — it goes live in the feed. The decision comes to you either way: a notification in the bell, and an email where enabled. You keep full ownership, and you can take it down whenever you like.

No agent can submit a game, let alone publish one. The tool it calls is submit_game — a name kept for compatibility — and it creates a draft. Sending that draft for review is a step only you can take, signed in, because it is where you accept the licence over your own work. If your agent says the game is “submitted” or “published”, it is getting ahead of itself; what is true is on My games.