Publish from your editor

The Fifth Door MCP server lets you build a game in your own editor with your own coding agent, then sign in and publish it to Fifth Door. It runs locally so it can read your project, and it talks to Fifth Door over HTTPS as your account. Works with Cursor, Claude Code, Codex, and any MCP-compatible client.

Once installed, the same server is how you manage a game after publishing: put it on Discover, record its gameplay preview, enter it in a jam, and read the Platform SDK docs. New tools land here as the platform grows; the @latest tag in the install config means each session runs the newest version.

Install

Cursor

Add to Cursor, or add to .cursor/mcp.json:

{
  "mcpServers": {
    "fifth-door": {
      "command": "npx",
      "args": ["-y", "@fifth-door/mcp@latest"]
    }
  }
}

Claude Code

claude mcp add fifth-door -- npx -y @fifth-door/mcp@latest

Codex

codex mcp add fifth-door -- npx -y @fifth-door/mcp@latest

Other clients

Most MCP clients take the same JSON as Cursor under mcpServers. VS Code and GitHub Copilot read .vscode/mcp.json with a servers key instead:

{
  "servers": {
    "fifth-door": {
      "command": "npx",
      "args": ["-y", "@fifth-door/mcp@latest"]
    }
  }
}

Sign in

Ask your agent to run the login tool. It returns a short code and a link. Open the link in a browser where you are signed in to Fifth Door, approve, and the agent is connected. The session is cached on your machine, so this happens once per computer. whoami shows which account is signed in; logout clears it.

For CI or scripting, create an API key on your account page and set it as FIFTH_DOOR_TOKEN in the MCP config instead of signing in interactively:

{
  "mcpServers": {
    "fifth-door": {
      "command": "npx",
      "args": ["-y", "@fifth-door/mcp@latest"],
      "env": {
        "FIFTH_DOOR_TOKEN": "fd_your_key"
      }
    }
  }
}

With Claude Code or Codex, pass it as --env FIFTH_DOOR_TOKEN=fd_your_key before the --.

Publish a game

Tell your agent to publish and it calls publish_game. A game is a static web bundle:

• An index.html at the root of the directory you publish, plus the files it references. Any framework or none. Assets are referenced by relative path.
• If the game has a build step, publish the build output (for example dist/) and point sourceDirectory at the project root.
• Up to 200 files and 300 MB per game.
• A slug: a stable lowercase identifier you choose. Publishing the same slug again updates that game and keeps its play URL.
• A playTarget: mobile (portrait phone, the default), mobile_landscape, desktop (wide frame with keyboard and mouse), or everywhere (fills whatever rectangle the host has). The host sizes the game to the target you pick, so build for that one.
• Cover art inside the bundle, passed as coverPath. Cards show the cover in a landscape 4:3 box (1200×900 works well) with no title text of their own, so draw the game's title into the artwork and keep it out of the corners.

You get back a play URL. New games are unlisted: the link works, but the game is not on Discover until you make it public.

Generate game art

Ask your agent for art. Files land in the assets/ folder of your game.

1. Matching a style. Every generation tool takes an optional styleReference: an image in your game to match. Pass the same one to assets that should look alike, or a different one where you want a different look. create_style_reference draws a sample image in a style you describe, to use as that reference.
2. Single images. create_image draws one prop, pickup, obstacle, or icon (transparent: true), a full-screen background (orientation: "tall"), or a seamless texture to tile in code (tileable: true with a tileRole such as surface for ground or parallax for a sky). A transparent cutout gets a .json beside it with its rest box.
3. Characters. create_character draws the character from every needed direction and writes one standing still per facing (assets/hero/down.png, ...). animate_sprite turns one of those stills into one motion (walk, run, attack, jump, idle, hurt, die, or a motion you describe).
4. Sets. create_image_set draws related items that share a frame (card faces, tiles, badges) against one anchor image so they match.
5. Changes. edit_image changes the look of an image, a sprite sheet, or a whole character in place. Editing a character updates every facing and every animation.

The tools upload only the files they need: the style reference you pass and the folder being worked on.

Sprite format. An animation is a folder with one sheet.png (every frame packed into a grid) and a frames.json describing it:

• frameWidth, frameHeight, cols, rows, count, padding: frames run left to right, top to bottom, with padding pixels between cells. Frame i starts at x = (i % cols) * (frameWidth + padding), y = floor(i / cols) * (frameHeight + padding). In Phaser, load.spritesheet(key, url, { frameWidth, frameHeight, spacing: padding }).
• fps and loop: playback speed, and whether the motion cycles or plays once.
• rest: the subject's visible bounds in its resting pose. Size the sprite and stand it on the ground by this box, not the frame rectangle, which includes empty margin.

A character still has a one-frame .json beside it with the same rest box. Games built from the Fifth Door devkit can use lib/sprites.js, which reads frames.json directly.

Long jobs. A tool waits up to about 45 seconds. Animations and character edits take longer, so the tool returns a job id instead. Call get_asset_job with that id and the same gameDir to write the files once the job is done. Without an id it lists recent jobs.

Daily budget. Each account gets 250 units a day, reset at midnight UTC. A style reference or single image costs 1, an image set 1 per item plus 1 for a new set, a character 2, an animation 5, and an edit 1 plus 2 per animation sheet it touches. Audio draws on the same budget: a music track costs 3, a sound effect 1 per take, a spoken line 1, and a dialogue scene 2. Failed jobs cost nothing. get_asset_job without an id shows what is left.

Generate game audio

Ask your agent for music, sound effects, and voice. Files are MP3s in the assets/ folder of your game. The audio tools upload nothing from your project.

1. Music. create_music writes a looping instrumental track, assets/background-music.mp3 by default. It is generated without an intro or ending, so it loops cleanly.
2. Sound effects. create_sound_effects writes assets/sfx/<name>.mp3 for every sound in one call. Describe each sound physically ("a thin coin landing on stone"). Leave durationSeconds off for short hits. loop: true makes a seamless ambience bed (rain, an engine hum) instead of a one-shot. variants writes numbered takes (step-1.mp3, step-2.mp3) for a sound that fires constantly.
3. Speech. create_speech writes one file per line, assets/voice/<name>.mp3, for lines the game plays on its own: narration, barks, announcements.
4. Dialogue. create_dialogue writes a whole conversation between characters as one file. The scene is performed together, so the timing between speakers sounds natural. It plays as a unit, so lines the game triggers one at a time belong in create_speech.

Voices. Every speech item and dialogue line names its voice, one of a fixed set of voices such as elder or sidekick (the tool lists them). Pass the same voice for a character every time to keep it sounding the same.

Playing it. Every take is leveled to the same loudness, so set each sound's volume relative to the others in code. For a game whose only sound is one music track, the SDK's window.FifthDoorPlatform.playMusic("./assets/background-music.mp3") loops it and starts on the first tap. Otherwise use your engine's audio (Phaser's sound manager, Howler, or Web Audio); loop ambience beds with Web Audio buffer sources rather than <audio loop>, which leaves a gap. Games running on Fifth Door go silent automatically when the player mutes or leaves the tab, so you do not need to handle that.

Editing a take. Process the MP3 locally with ffmpeg and write to a new file rather than regenerating, which gives a different take. Starting points: an old radio -af "highpass=f=300,lowpass=f=3000,acrusher=bits=8:mix=0.3", a telephone -af "highpass=f=400,lowpass=f=3400", underwater -af "lowpass=f=700,aecho=0.8:0.6:60:0.3". Join dialogue scenes with ffmpeg's concat demuxer.

What happens to your source

Publishing uploads your game's authored source alongside the playable bundle. Fifth Door stores it with the game and uses it to run the platform: reviewing games for safety and quality, classifying and tagging them for Discover, and powering creator tools such as gameplay previews. Public games can be remixed by other creators, which copies the game into their own Studio; keep a game unlisted if you do not want that.

Publishing also creates a page for the game in Studio, Fifth Door's in-browser editor, where you can edit its listing and see how it is being played. Nothing is generated or changed there unless you ask.

After publishing

• Discover. set_game_visibility with public lists the game on Discover; unlisted takes it back to link-only. Going public also queues a gameplay preview recording if the game has none.
• Gameplay previews. Discover loops a short muted clip on a game's card. generate_game_preview records one from the published game (an agent plays it and a worker records the liveliest six seconds; allow several minutes and poll get_game_preview_status). set_game_preview uses a video you already have, trimmed to its first eight seconds. clear_game_preview goes back to the cover.
• Game jams. list_jams shows this week's jam and its theme. enter_jam enters a public game that first went public during the jam week; withdraw_from_jam takes it out while entries are open.
• Your games. list_my_games lists what the account has published and flags games missing a cover or a preview.

Platform features

The Platform SDK is optional. A plain static game publishes and runs without it. When a game needs saved progress, shared records, multiplayer rooms, presence, in-game LLM calls, daily puzzles, notifications, or a shop, the SDK provides them so you do not build them yourself. A shop sells the items your game declares for keys, the Fifth Door currency: the platform shows the price and the confirm, and the keys players spend go to your account to spend on Fifth Door. They cannot be cashed out. Your agent can read the docs for one SDK release with list_sdk_services and get_sdk_docs without signing in, or you can read them at /docs/sdk.

Tools

Account

Publish

Game art and audio

Your games

Gameplay previews

Game jams

Platform SDK docs

Configuration

Everything the server needs arrives through environment variables in the MCP client config.

Credentials from login are cached in ~/.config/fifth-door/credentials.json.