Godot MCP

# Godot MCP: give your AI agent a real game engine

One command connects Claude Code, Cursor, Codex, and 28 other agents to Summer Engine, compatible with Godot 4\. Your agent builds scenes, writes GDScript, presses play, reads the errors, and generates assets.

$ npx -y summer-engine@latest setup claude-code --yes

Install for your client[Download Summer Engine](https://www.summerengine.com/es/download)

The short answer

A Godot MCP server is a Model Context Protocol server that lets an AI client such as Claude Code, Cursor, Codex, or Claude Desktop work on a Godot project through structured tools. Summer Engine ships a free, MIT-licensed MCP server: run one setup command, open your project in the Summer Engine desktop app (compatible with Godot 4), and your agent can create scenes, write GDScript, run the game, read debugger errors, and generate 3D, image, and audio assets.

Engine control and asset search are free. Cloud generation (3D models, images, audio, video) uses credits.

What it is

## What a Godot MCP server does

Coding agents can already read files, edit scripts, and run terminal commands. MCP connects them to the running editor: read the scene tree, add a node, set a property, run the project, and fetch the errors. One server can expose those tools to Claude, Cursor, Codex, and other MCP clients.

### Editor and file level

Most community Godot MCP servers read and edit your project files, create scenes and nodes, and launch the project to capture debug output. They work with the stock Godot editor and are a solid choice for code-focused help.

### Engine level

Summer Engine exposes the running engine itself: the live scene tree, Play mode, runtime probes and input, screenshots, and snapshot diffs. The agent can check its own work in the game instead of guessing from the files.

### Plus generation

Generate images, 3D models, audio, video, and motion, slice sprite sheets, and search the Summer asset library. Generation and search work with the desktop app closed. Importing an asset into a Summer project needs the app open with that project loaded.

Install

## Install Godot MCP in your client

Start with Node.js 20 or newer. The setup command writes the MCP entry into your client config, installs the agent skills, and runs a health check. It does not install or open the desktop app. Swap the agent name for your client. Add --scope project for a project-level config. Restart or reload your client if the tools do not appear.

### Claude Code

```
npx -y summer-engine@latest setup claude-code --yes
```

[Claude Code guide](https://www.summerengine.com/es/mcp/how-to-make-games-in-claude-code)

### Cursor

```
npx -y summer-engine@latest setup cursor --yes
```

[Cursor guide](https://www.summerengine.com/es/mcp/how-to-make-games-in-cursor)

### Codex CLI

```
npx -y summer-engine@latest setup codex --yes
```

[Codex CLI guide](https://www.summerengine.com/es/mcp/how-to-make-games-in-codex)

### Claude Desktop

```
npx -y summer-engine@latest setup claude-desktop --yes
```

### Devin Desktop (formerly Windsurf)

```
npx -y summer-engine@latest setup windsurf --yes
```

[Devin Desktop (formerly Windsurf) guide](https://www.summerengine.com/es/mcp/how-to-make-games-in-devin-desktop)

### VS Code with GitHub Copilot

```
npx -y summer-engine@latest setup vscode-copilot --yes
```

### Cline

```
npx -y summer-engine@latest setup cline --yes
```

[Cline guide](https://www.summerengine.com/es/mcp/how-to-make-games-in-cline)

### Kilo Code

```
npx -y summer-engine@latest setup kilo-code --yes
```

[Kilo Code guide](https://www.summerengine.com/es/mcp/how-to-make-games-in-kilo-code)

### OpenCode

```
npx -y summer-engine@latest setup opencode --yes
```

[OpenCode guide](https://www.summerengine.com/es/mcp/how-to-make-games-in-opencode)

### Zed

```
npx -y summer-engine@latest setup zed --yes
```

### Antigravity

```
npx -y summer-engine@latest setup antigravity --yes
```

### LM Studio (local models)

```
npx -y summer-engine@latest setup lm-studio --yes
```

[LM Studio (local models) guide](https://www.summerengine.com/es/mcp/how-to-make-games-in-lm-studio)

### Prefer to edit the config yourself?

This is the standard entry for clients that use mcpServers JSON. Setup handles your client’s config format; --print previews its entry without writing files:

```
{
  "mcpServers": {
    "summer-engine": {
      "command": "npx",
      "args": ["-y", "summer-engine@latest", "mcp"]
    }
  }
}
```

1. ### 1\. Open your project in Summer Engine  
Engine tools drive the Summer Engine desktop app. Download it free, then open a new project or a compatible Godot 4 project.  
```  
npx -y summer-engine@latest install  
```
2. ### 2\. Sign in for cloud tools  
Asset generation, sprite sheet slicing, and library search run on Summer servers and need an account. Engine tools do not.  
```  
npx -y summer-engine@latest login  
```
3. ### 3\. Check the connection  
Doctor checks Node, CLI and skill versions, login, the engine installation, the local API, project memory, and an MCP startup and tool-list handshake. Check local-api for the editor connection and mcp-boot and mcp-tools-list for server readiness. It does not prove your client has loaded the tools.  
```  
npx -y summer-engine@latest doctor --json  
```

Tools

## Godot MCP tool list

Examples from summer-engine 4.3.0’s default v4 surface. Core editor tools keep their familiar names. For other jobs, summer\_search finds the operation and its exact input, then summer\_call runs it. The older 3.x cloud tool names are legacy names and may not appear in the default tool list. Ask in plain language; your agent discovers the right operation.

### Scenes and nodes

Build and edit the scene tree in the open project.

* `summer_create_scene`
* `summer_open_scene`
* `summer_get_scene_tree`
* `summer_add_node`
* `summer_set_prop`
* `summer_set_resource_property`
* `summer_instantiate_scene`
* `summer_connect_signal`
* `summer_save_scene`

### Scripts and files

Read and write GDScript, run editor scripts, and look up engine APIs instead of guessing.

* `summer_read_file`
* `summer_write_file`
* `summer_replace_text`
* `summer_get_script_errors`
* `summer_run_script`
* `summer_api_docs`

### Play and debug

Run the game, collect errors and warnings, and see what the player sees.

* `summer_play`
* `summer_stop`
* `summer_get_diagnostics`
* `summer_get_debugger_errors`
* `summer_get_console`
* `summer_screenshot`
* `summer_snapshot_diff`

### Runtime control

Drive the running game: send input, probe state frame by frame, set values, spawn nodes.

* `summer_game_input`
* `summer_game_probe`
* `summer_game_control`
* `summer_get_runtime_tree`
* `summer_runtime_set`
* `summer_runtime_call`
* `summer_runtime_spawn`

### Assets and operation discovery

Find cloud generation, asset search, and other operations with summer\_search. Asset generation and library search need sign-in but no open editor. Import an exact asset ID into a Summer project with the desktop app open and that project loaded.

* `summer_search`
* `summer_call`
* `summer_import_asset_by_id`

### Project and docs

Read the open project, change project settings and input maps, and find Summer skills and tool guides.

* `summer_get_project_context`
* `summer_project_setting`
* `summer_input_map_bind`
* `summer_docs_search`
* `summer_docs_read`

Examples

## Prompts to try once it is connected

Paste any of these into your agent with a project open in Summer Engine.

### Build and self-check

The agent builds the scene, runs it, and fixes what the debugger reports.

```
Add a CharacterBody3D player with WASD movement and a follow camera. Press play, read the errors, and fix them.
```

### Test like a player

Input and probes let the agent verify behavior in the running game.

```
Run the game, walk the player into the lava, and confirm the death screen appears.
```

### Generate an asset in place

Cloud generation plus import, with collision set up in the scene.

```
Generate a low-poly treasure chest, import it next to the player, and give it a collision shape.
```

### 2D sprites

Generate a sheet, slice it into frames, and wire the animation.

```
Make a sprite sheet for a slime enemy with a walk cycle, slice it, and add an AnimatedSprite2D.
```

### Fix from real errors

The agent reads the actual debugger output instead of guessing.

```
Read the debugger errors from the last playthrough and fix the null reference.
```

### Before and after

Snapshot diffs show exactly what changed in the scene.

```
Take a world snapshot, add fog and a sunset sky, then show me the diff and a screenshot.
```

Compare

## Summer Engine MCP vs other Godot MCP servers

An honest look at the three options people compare most. Pick the one that matches where you want to work.

|                                     | Summer Engine MCP                                  | Coding-Solo godot-mcp                      | GDAI MCP                                    |
| ----------------------------------- | -------------------------------------------------- | ------------------------------------------ | ------------------------------------------- |
| Where it runs                       | Summer Engine desktop app, compatible with Godot 4 | Stock Godot editor, launched by the server | Plugin inside the stock Godot editor (4.2+) |
| Price and license                   | Free, MIT. Cloud generation uses credits           | Free, MIT                                  | $19 one-time, per its website               |
| Create scenes and nodes             | Yes                                                | Yes                                        | Yes                                         |
| Run the game and read debug output  | Yes                                                | Yes                                        | Yes                                         |
| Screenshots of the running game     | Yes                                                | Not listed                                 | Yes                                         |
| Simulated input in the running game | Yes, plus frame-stamped probes                     | Not listed                                 | Yes                                         |
| Generate 3D, image, audio, video    | Yes                                                | No                                         | No                                          |
| Setup                               | One command for 31 agents                          | npx entry per client                       | Plugin plus client config                   |

Community server features as listed on the Coding-Solo/godot-mcp README and gdaimcp.com on 2026-09-25\. Both projects move fast, so check them for current capabilities. If you must stay in the stock Godot editor, pick one of them. If you want generation and runtime tools in one server, pick Summer.

Fixes

## Troubleshooting

### The agent says the engine is not running

Engine tools need the Summer Engine desktop app open with a project loaded. Status shows the connection and auth state.

```
npx -y summer-engine@latest status
```

### Cloud tools return an auth error

Generation, slicing, and asset search need a signed-in account. Sign in once; the token is stored for every client.

```
npx -y summer-engine@latest login
```

### No Summer tools after setup

Restart or reload the client so it rereads its MCP config. Run doctor --json and inspect mcp-boot and mcp-tools-list. If those pass but the tools are absent, check the client’s MCP settings; doctor does not verify the client has loaded them.

```
npx -y summer-engine@latest doctor --json
```

### Running a local model

Tool schemas overflow small context windows silently. Raise the context to 32k or more and use a model with native tool calling.

### Want the config in the repo

Write a project-level config so everyone on the team gets the same server.

```
npx -y summer-engine@latest setup cursor --scope project --yes
```

### See the config before writing it

Dry run shows the planned changes; print outputs the snippet without touching files.

```
npx -y summer-engine@latest setup claude-desktop --print
```

## Godot MCP FAQ

What is Godot MCP?

Godot MCP means a Model Context Protocol server for Godot. It exposes tools an AI client can call, such as reading the scene tree, adding nodes, editing scripts, and running the game. Coding agents can already work with files and terminal commands; an editor connection adds access to the scene state and diagnostics the server exposes.

How do I install a Godot MCP server?

With Node.js 20 or newer, run npx -y summer-engine@latest setup followed by your agent name, for example claude-code, cursor, codex, or claude-desktop, and add --yes to skip prompts. The command writes the MCP config, installs the agent skills, and runs a health check. Install the Summer Engine desktop app separately and open your project in it for editor tools and asset import. Restart or reload your client if the tools do not appear.

Is the Summer Engine Godot MCP server free?

Yes. The server and CLI are MIT open source and free, and engine control and asset search cost nothing. Cloud generation of 3D models, images, audio, and video uses credits, and the model your client runs is billed by that client as usual.

Does it work with Claude Code and Claude Desktop?

Yes. Use setup claude-code for Claude Code and setup claude-desktop for Claude Desktop. Both get the same server entry, which runs npx -y summer-engine@latest mcp.

Can a Godot MCP server run my game?

Some can. Summer Engine, Coding-Solo godot-mcp, and GDAI MCP all run the project and return debug output. Summer also sends input to the running game, probes its state frame by frame, and takes screenshots, so the agent can test behavior the way a player would.

Does Summer MCP work with the stock Godot editor?

No. Its engine tools drive the Summer Engine desktop app, which is compatible with Godot 4 and opens compatible Godot 4 projects. If you need to stay in the stock editor, a community server such as Coding-Solo godot-mcp or GDAI MCP is the better fit. Summer cloud tools like asset generation work from any client either way.

Which AI clients are supported?

The setup command supports Claude Code, Claude Desktop, Codex, Cursor, Devin Desktop, Antigravity, Cline, Kilo Code, GitHub Copilot in VS Code, Visual Studio, and JetBrains, OpenCode, Zed, Kiro, Goose, Warp, Junie, Amp, and LM Studio. Use setup for your client’s config format; other MCP clients can use a manual server entry.

Can I use a local model with Godot MCP?

Yes, through an MCP client that runs local models, such as LM Studio, OpenCode with Ollama, Kilo Code, or Goose. Raise the context window to 32k or more, because tool schemas overflow the small defaults without an error.

Keep going

## More on Godot, MCP, and AI agents

[Summer MCP and CLI The full agent layer: CLI, MCP server, skills, and per-agent guides. Open](https://www.summerengine.com/es/mcp)

[Make games in Claude Code Step-by-step setup and first build with Claude Code. Open](https://www.summerengine.com/es/mcp/how-to-make-games-in-claude-code)

[Best Godot MCP server A ranked roundup of the Godot MCP servers people compare. Open](https://www.summerengine.com/es/blog/best-godot-mcp-server)

[Best AI tools for Godot Editor plugins, MCP servers, and AI-native engines, ranked by the job each one does. Open](https://www.summerengine.com/es/blog/best-ai-tools-for-godot)

[Claude for Godot How to connect Claude to a Godot 4 project and what it can do. Open](https://www.summerengine.com/es/blog/claude-for-godot)

[Godot AI Bring a compatible Godot 4 project into Summer and build with AI. Open](https://www.summerengine.com/es/godot-ai)

## Open your project. Connect your agent.

Summer Engine is a free download for macOS and Windows. The MCP server and CLI are MIT open source.

Source: https://www.summerengine.com/es/godot-mcp

---

## Machine-readable resources

- Site index for agents: https://www.summerengine.com/llms.txt
- Full inlined content: https://www.summerengine.com/llms-full.txt
- Porting catalog: https://www.summerengine.com/llms-porting.txt
- Structured catalog: https://www.summerengine.com/agent-catalog.json
- Sitemap: https://www.summerengine.com/sitemap.xml
- Developer resources: https://www.summerengine.com/docs