MCP servers for game development, browser first

An MCP server gives your coding agent tools it doesn’t have out of the box, like a browser to play your game in, a line into Blender, or control of the Godot, Unity or Unreal editor. Install a browser server first, and then one for the tool you build in.

MCP stands for Model Context Protocol, the open standard behind that connection. A server exposes tools the agent can call and resources it can read, and it can offer prompt templates too (MCP docs).

This guide follows the specification dated July 28, 2026 (versioning). We checked the server overview in September, and the Blender session and the Unity setup and prices at the start of October.

Start with a browser and the editor you use

You don’t need a whole collection of them. One browser server plus one for your engine or art tool is plenty to start with.

Server	What your agent can do with it	Official?
Playwright MCP	Open the game, click, press keys, screenshot, read the console	Yes, Microsoft
Chrome DevTools MCP	Record performance traces, throttle the CPU or network, run Lighthouse	Yes, Chrome team
Blender MCP	Run model-written Python in your Blender session	Yes, Blender Lab
mcp-for-blender	Scene control plus asset search and 3D generation services	No, community
godot-mcp and godot-ai	Launch the project, read debug output, edit scenes	No, community
Unity CLI (unity mcp)	Drive a running Unity editor	Yes, Unity
Unreal MCP	Editor toolsets in Unreal Engine 5.8	Yes, experimental
Aseprite servers	Draw and edit pixel art	No, community
Context7	Current, version-specific library docs in the prompt	Yes, Upstash

Let the agent play your game in a browser

Playwright MCP is the one to install first for any browser game. In Claude Code it’s a single command.

claude mcp add playwright npx @playwright/mcp@latest

In Codex it’s codex mcp add playwright npx "@playwright/mcp@latest", and in Cursor you add npx @playwright/mcp@latest under Settings, then MCP (README). Once it’s connected, the agent gets tools such as browser_navigate, browser_press_key, browser_evaluate, browser_console_messages and browser_take_screenshot, so it can load the game, press keys and see what happened for itself.

Canvas games need one extra flag because of how Playwright sees a page. It normally works through the page’s accessibility tree, and to that tree a canvas game is just a single element. Its vision capability (--caps=vision) adds coordinate tools such as browser_mouse_click_xy, and Playwright’s docs name canvas and WebGL apps as the use case (vision mode). The loop then becomes screenshot, click at a coordinate, screenshot again.

Even better, let the game tell the agent what’s going on.

browser_evaluate runs JavaScript in the page, so if your game exposes a small state function on window with the score, lives and player position, the agent can just read it instead of guessing from screenshots. Playtesting games with AI builds that hook step by step.

Oddly enough, Playwright’s own README points coding agents to its CLI with skills as the more token-efficient option, and keeps MCP for exploratory sessions (README, Playwright CLI). So if your agent runs shell commands anyway, try the CLI first.

Chrome DevTools MCP is more for measuring than for playing. performance_start_trace records a trace with Core Web Vitals, and emulate throttles the CPU or the network (tool reference). There’s also lighthouse_audit, which oddly leaves performance to the trace and covers accessibility, SEO and best practices.

A handy trick is to ask the agent to record ten seconds of play on a throttled CPU, which gives you a rough idea of how the game runs on a cheap phone.

claude mcp add --scope user chrome-devtools -- npx -y chrome-devtools-mcp@latest

Google collects usage statistics by default, and the --no-usage-statistics flag turns that off if you’d rather it didn’t (repo).

Let the agent edit a prop in Blender

Blender has an official MCP server from Blender Lab. It comes as an add-on plus a standalone server, and it needs Blender 5.1 or newer (Blender Lab).

Anthropic announced it in April 2026 as a connector built by the Blender developers themselves (Anthropic). It works through Blender’s Python API, so the model writes the code and the server runs it in your open session. Blender’s own examples also cover jobs that don’t make anything, such as finding performance bottlenecks in a scene and documenting geometry node setups.

Blender’s page also warns that the server runs model-written code “without any guards in place” to stop your data from being deleted or sent elsewhere. It advises a virtual machine or a computer without sensitive data (Blender Lab), and we’d take that advice literally.

There’s a community option too, mcp-for-blender (formerly blender-mcp, MIT). It adds plenty of sources, with search and download for Poly Haven, Sketchfab and Poly Pizza, plus generation through Hyper3D Rodin, Hunyuan3D and Tripo, and it calls itself a third-party integration, not made by Blender (README).

If you set BLENDER_MCP_SAFE_MODE=1, it checks scripts and blocks direct file access, other programs and network calls, while normal Blender saving, import and export still work. That’s a nice safety net, but keep the isolation advice above anyway.

Turn one crate into a game-ready GLB

To see what this looks like in practice, take one wooden crate, generated or downloaded, and save it locally as crate-source.glb. Stick to a static, unrigged, opaque, nonmetal prop for this exercise.

We’re aiming for at most 2,000 triangles, one material and, if baking is needed, one 1,024 by 1,024 base-color image. Those are just example budgets, not limits for every game.

Both servers can run Python in Blender, and the community server also lists scene inspection, material editing and export_scene for GLB/FBX (Blender Lab, community README). The prompts below only ask the agent to use those capabilities for ordinary Blender operations. Send one, check the result, and only then send the next.

1. Import and count.

   Import crate-source.glb from my asset folder. Keep the original file untouched and save a working copy as crate-game.blend. Identify the crate mesh and report its triangle count after modifiers, material slots, image sizes, dimensions and transforms. Stop if it has a rig, animation, shape keys or more than one mesh; this session is for a single static prop.

   Make sure the report counts only the crate. Blender’s Scene Statistics tells faces and triangles apart, so it’s a handy cross-check as long as you leave unrelated scene objects out (manual). Write down the starting count, and keep in mind that a face count isn’t your triangle budget.

2. Decimate to the budget.

   If the crate exceeds 2,000 triangles, add a Decimate modifier in Collapse mode with Triangulate enabled. Start Ratio at 2,000 divided by the starting triangle count, then adjust and recount the evaluated mesh until it is at or below the budget. Keep the modifier editable. Show the crate from several sides before and after.

   Look at the silhouette, the plank edges, the holes and the shading at the size the crate will really appear in your game. Ratio uses triangles in its calculation, but you still need to check the resulting count (Decimate manual). If the shape falls apart before it reaches the budget, change the mesh or the budget before you carry on.

3. Apply transforms.

   Set the crate’s width to one meter and orient it upright. In Object Mode, use Object > Apply > Rotation & Scale on the crate. Report dimensions, rotation and scale again.

   Rotation should now be zero and scale one on every axis, while the visible size and shape stay put. Applying rotation and scale moves those transforms into the object data, and Blender advises doing it before rigging and animation (Apply manual).

4. Keep one texture set, or bake one.

   If the crate already has one glTF-compatible material and texture set, keep it and skip baking. Otherwise, simplify this matte wooden prop to one base-color atlas and constant roughness. Stop if metal, transparency, emission or normal-map detail is essential to its appearance.

   Check that this simplification actually suits the prop. If you’re taking the baking route, carry on with the next prompt.

   Preserve the source UV maps. Explicitly bind each source texture to its original map with a UV Map node. Add a separate nonoverlapping UV map named crate-atlas for baking. Create a 1,024 by 1,024 image named crate-basecolor, and make an unconnected Image Texture node using that same image the active bake target in every source material.

   The source textures should still line up. A UV Map node can name a specific map, so changing the bake layout doesn’t have to change how the source is sampled (UV Map manual).

   In Cycles, use Render > Bake with Bake Type Diffuse: enable Color, disable Direct and Indirect. Bake to crate-basecolor using crate-atlas as the destination UV map, save the image as crate-basecolor.png, and show it before replacing any materials.

   Look over the atlas for blank patches and UV seams. A bake needs UVs and an active image target, and Diffuse with only Color leaves the lighting out (baking manual). Then send the last prompt for this step.

   Assign one Principled BSDF material to every face. Connect a UV Map node naming crate-atlas to the baked Image Texture, and that texture to Base Color. Set Metallic to 0 and Roughness to 0.8. Show the result beside the source.

   Compare the final material with the source. The glTF exporter picks up the image connected to Base Color, plus the Metallic and Roughness values (material manual).

5. Set the origin.

   Put the 3D cursor at the center of the crate’s bottom face. Use Object > Set Origin > Origin to 3D Cursor. Then move the crate so its origin is at world zero. Save crate-game.blend.

   The origin should sit on the bottom, the crate should rest on the ground plane, and rotating it should turn it around that point. Origin to 3D Cursor moves the origin to wherever the cursor is (origin manual).

6. Export and inspect the file.

   Select only the crate. Export crate.glb through File > Export > glTF 2.0 (.glb, .gltf). Choose Format: glTF Binary (.glb), enable Selected Objects and Apply Modifiers, include UVs and Normals, and export the crate’s material and textures. Report the exported file path and the final evaluated triangle count.

   Make sure the selected object is the working crate. Apply Modifiers exports the evaluated mesh, and glTF Binary packs the mesh data and image textures into one file (export manual). You can inspect that file from your terminal once you’ve installed the glTF Transform CLI.

   npm install --global @gltf-transform/cli
   gltf-transform inspect crate.glb

   The mesh report should show at most 2,000 triangles, and the material and texture reports should match the set you kept or baked. On the baked route, that’s one material and one 1,024 by 1,024 image.

   Keep in mind that inspect only reports what’s in the file. It doesn’t prove the model looks right, so load the GLB in your game and check orientation, scale, ground contact, shading and seams before you call it ready (CLI docs).

If you’re starting from a picture instead, image to 3D for games covers that. Blender’s also a good place to retarget animation. You import a motion clip, map it onto your character and export one GLB.

AI 3D animation for games goes through the steps, and the Kimodo guide applies them to NVIDIA’s text-to-motion model.

Connect the agent to the editor you build in

Godot doesn’t have an official server, so you’re choosing between community ones. You add Coding-Solo/godot-mcp (MIT) with claude mcp add godot -- npx @coding-solo/godot-mcp, and it offers launch_editor, run_project, get_debug_output, create_scene and add_node (README).

If you installed it a while ago, it’s really worth updating, because versions before 0.1.1 passed the project path to a shell, so a crafted path could run commands on your computer (advisory).

hi-godot/godot-ai (MIT, Godot 4.7+) goes wider, with a bunch of tools, 46 of them, that build scenes, edit nodes and scripts, wire signals and set up UI, materials and animation (README). satelliteoflove/godot-mcp is the neat one for testing, because it can freeze the game clock, step exact slices of time and inject input, which is exactly what a repeatable playtest needs (README).

To put the connection to work, our Godot guide follows one project all the way from rules and run/debug checks to a single-threaded Web export, itch.io and an iframe.

Unity MCP with Claude Code is free through the official Unity CLI. Unity deprecated the server that lived inside com.unity.ai.assistant, and unity mcp replaces it, while community servers aren’t affected. The CLI is free and needs no Unity AI subscription, though driving a running editor through its Pipeline package requires Unity 6.0 LTS or later (migration docs). Unity does still label the CLI experimental (CLI introduction).

To set it up, install the CLI, open your project in the editor and run these commands from the project directory. Unity’s setup signs you into your Unity account, installs the Unity Pipeline package and its dependencies, and checks the connection (Pipeline setup).

unity auth login
unity pipeline install
# Wait for the editor to finish recompiling before this check.
unity pipeline list
unity mcp configure --list

You’re looking for Pipeline: Installed. Then run unity mcp configure <client>, with <client> replaced by the Claude Code client name the list shows. Unity’s release notes name Claude Code among the supported clients, and the migration guide gives claude, cursor, vscode and windsurf as examples.

If you also keep the in-editor assistant installed, update it to version 2.13 or later to avoid the CLI conflict Unity documents.

Is Unity MCP paid? No. Unity’s AI FAQ says its MCP server is free, requires no AI tools subscription and consumes no Unity credits, and the pricing page includes CLI and MCP access in free Unity Personal. That doesn’t waive the editor plan’s eligibility rules, though, and it doesn’t come with an AI client subscription.

Unity’s in-editor assistant is a separate thing with its own terms and charges (AI FAQ, plans and pricing). Those charges are for the assistant, so the CLI’s MCP bridge stays free either way.

Assistant plan	Allowance
Personal trial	14 days, 1,000 one-time credits
Personal subscription	$10 per month, 1,000 monthly credits
Pro, Enterprise and Industry	Assistant access and credits included with the seat

Unity connection	License or access	Supported editor versions	Main capabilities
Official Unity CLI MCP	Free; no Unity AI subscription or Unity credits (docs, FAQ)	Unity 6.0 LTS+ for the running-editor Pipeline connection	Exposes connected editor commands through MCP (release notes)
CoplayDev/unity-mcp	Free, MIT (README)	Unity 2021.3 LTS through 6.x	Scenes and GameObjects, C# scripts and assets, tests, profiling and builds (README)
IvanMurzak/Unity-MCP	Free, Apache-2.0 (README, FAQ)	Unity 2022.3+ (project FAQ)	gameobject-create, assets-find, script-execute, tests-run and profiler tools; supports editor and runtime integration (README)

If you’re weighing Unity MCP vs Coplay, it helps to know that CoplayDev/unity-mcp is itself a community MCP bridge. Its README separates the free MCP for Unity project from the premium Aura for Unity assistant (README), so you can see which part costs money. Pick the bridge by the editor version and the tools you need, and treat a paid assistant as a separate decision.

Unreal Engine 5.8 ships an experimental Unreal MCP plugin that serves on http://127.0.0.1:8000/mcp. The console command ModelContextProtocol.GenerateClientConfig ClaudeCode writes the client config for you, and toolsets such as SceneTools and ActorTools come from Epic’s toolset plugins, most of them written in Python. Epic’s docs say there’s no authentication layer, so keep it on your own machine (Epic docs).

Add art tools or current docs when the project needs them

For sprites, diivi/aseprite-mcp (MIT) exposes over a hundred Aseprite tools. Before you hand it to an agent, know that one of them is a Lua escape hatch that runs unrestricted code on your computer (README).

If you’d rather get images, audio and 3D models from hosted services, fal.ai runs an official remote server. The server itself is free, but of course each model run is billed (fal docs).

Context7 is for a different problem, an agent writing code for a library version you don’t have. It puts up-to-date, version-specific documentation and code examples for your libraries into the prompt, so the agent writes against the version you actually installed. It’s free, with an optional key for higher rate limits, and it runs as an MCP server or as a CLI with skills (Context7).

Codex’s docs even use it as their example, with codex mcp add context7 -- npx -y @upstash/context7-mcp.

Set it up once, per project

If you work in a team, set servers up per project, so everyone who works on the game gets the same tools. In Claude Code, --scope project writes the server to .mcp.json at the repo root, and you commit that file so the team shares it (Claude Code MCP docs). Keep keys out of it with ${VAR} placeholders, which Claude Code fills in from your environment, and ${VAR:-default} adds a fallback.

Codex reads servers from ~/.codex/config.toml, or from .codex/config.toml in a trusted project, and the ChatGPT desktop app, the CLI and the IDE extension all share that setup (Codex docs). Cursor keeps project servers in .cursor/mcp.json (Cursor docs).

Then only turn on the two or three servers you’re using this week, because every server adds tool descriptions to the agent’s context. Anthropic calls command-line tools such as gh “the most context-efficient way” to reach outside services (best practices).

Pin trusted servers and keep private data apart

Every server on this page can run code on your machine, so a little care goes a long way. The MCP specification says tools represent arbitrary code execution, and that hosts must ask for consent before calling them (spec).

Claude Code does ask before it uses a project’s .mcp.json servers in an interactive session. In claude -p runs, Agent SDK sessions and cloud sessions, though, it loads them without asking, unless you block them with --strict-mcp-config or disabledMcpjsonServers (Claude Code MCP docs).

1. Install from sources you trust, and pin versions. Read the README, check who maintains it, and update when an advisory lands, like the Godot one above.

2. Keep the lethal trifecta apart. Simon Willison’s rule is never to give one agent private data, untrusted content and a way to send data out, all at the same time (Willison). A browser server reads untrusted pages, so don’t pair it with your secrets.

3. Sandbox anything that runs code. Blender, Aseprite’s Lua tool and Unreal’s unauthenticated endpoint all run whatever the agent writes, so a separate user account or a virtual machine is pretty cheap insurance.

Put the servers to work

Claude Code skills for game development sets up skills and hooks that tell the agent when to use these tools. Playtesting games with AI shows Playwright in practice, with a game state hook.

If you’re still picking an engine, best game engine for vibe coding puts Three.js, Phaser, Godot and Unity side by side. You can also browse the Godot games and Unity games in our catalog.