SkillAgentSearch skills...

godot-breakpoint-mcp

MCP for Godot (4.2+)

Install / Use

claude mcp add jlivingston-Cipher -- npx -y github:jlivingston-Cipher/godot-breakpoint-mcp

If the server publishes to npm under a different name, use that package instead โ€” check the repo README.

About this skill
๐Ÿ”Œ

MCP Server

Model Context Protocol server

Quality Score

65/100

Supported Platforms

Claude Code
Claude Desktop

Tags

Our assessment of godot-breakpoint-mcp

godot-breakpoint-mcp scores 65/100 on our quality scale, 4016th of 4,716 Development & Engineering skills we index.

Its MCP Server is 39 KB long, well organised into 29 sections with 12 code examples: a thorough specification that gives an agent plenty to work with.

It has 10 GitHub stars, so there is little community track record yet; judge it on its content.

Substance
30/30
Structure
20/20
Description
4/15
Adoption
4/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 3 days ago, so godot-breakpoint-mcp is actively maintained.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 92/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit โ€” read the skill file before letting an agent act on it.

godot-breakpoint-mcp compared with similar skills

All 4 of these similar skills score higher than godot-breakpoint-mcp; compare them before choosing.

SkillScoreStarsUpdatedFormat
godot-breakpoint-mcp (this skill)by jlivingston-Cipher65103d agoMCP Server
taste-skillby Leonxlnx100118.9k11d agoCLAUDE.md
Agent-Reachby Panniantong100113.3k12d agoCLAUDE.md
hyperframesby heygen-com10087.1ktodayCLAUDE.md
rufloby ruvnet10082.1ktodayCLAUDE.md

Frequently asked questions

How do I install godot-breakpoint-mcp?
Run claude mcp add jlivingston-Cipher -- npx -y github:jlivingston-Cipher/godot-breakpoint-mcp. The install tabs above show the steps for each supported agent.
Which AI agents does godot-breakpoint-mcp work with?
It is written for Claude Code and Claude Desktop, as a MCP Server file. Other agents that read the same format can often use it too.
Is godot-breakpoint-mcp safe to use?
It is MIT-licensed and scores 92/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is godot-breakpoint-mcp still maintained?
The repository was last updated 3 days ago, so godot-breakpoint-mcp is actively maintained.

Breakpoint MCP

A Model Context Protocol server that brings the Godot game engine into an AI assistant's development loop โ€” authoring scenes, writing type-checked GDScript, running the project, and debugging the live game. Developed and tested with Claude; MCP is an open protocol, so other clients can connect too (see Compatibility).

npm 1.95.0 ยท addon 1.24.0 ยท full 298 / secure-default 285 tools ยท 6 MCP resources ยท MIT. The host builds against the stable @modelcontextprotocol/sdk 1.x API and is exercised by a 1043-test suite plus real-Godot integration jobs on Node 18/20/22.

Breakpoint MCP connects an MCP-compatible AI assistant to a running Godot editor and game. Instead of only scaffolding files, the assistant can open a scene, add and wire nodes with full undo/redo, write GDScript with type-aware completion and diagnostics, set a breakpoint and step through a failure from real program state, and then drive the running game โ€” the same inner loop a human developer uses.

It speaks Godot's own protocols โ€” the editor plugin's loopback bridge, and Godot's built-in language server (LSP) and debug adapter (DAP) โ€” rather than reimplementing them, so behavior tracks the engine you already have.

Why Breakpoint?

Breakpoint is an MCP server that drives Godot through the engine's own interfaces: the editor plugin's loopback bridge for scene/node/resource work, a runtime bridge inside the running game, the headless CLI, and โ€” the part that sets it apart โ€” Godot's built-in language server (LSP) and debug adapter (DAP), to which Breakpoint speaks as a real client. Most Godot MCP servers stop at the first group: they create and edit scenes and scripts, take screenshots, and read the output log. Several now add stepping too โ€” but they drive Godot's internal editor debugger and present it in "DAP-style" shapes rather than speaking the Debug Adapter and language-server protocols as a client. Breakpoint is that client, for GDScript and C#, and its breakpoints are proven to stop execution by integration tests run against real Godot binaries in CI. That is the difference between observing a running game from the outside and stopping inside it at real program state.

Two differentiating capabilities are the reason to reach for Breakpoint:

  • A step-debugger for GDScript and C#. Set a breakpoint, step, read the real call stack and variable values, watch expressions, and evaluate in the paused frame โ€” over Godot's Debug Adapter (and netcoredbg for C#). This is the difference between inspecting state and reading logs: the assistant can stop at the failure and look at actual values instead of inferring them from print() output and re-runs. A runnable example lives in example/demo/: a buggy melting-snowman scene where the debugger stops on ice -= melt and reveals melt = -2 โ€” a mild warm spell growing the ice instead of melting it. The same bug is mirrored in C# at example-csharp/demo/ (DemoSnowman.ApplyWarmth), diagnosed the same way over netcoredbg โ€” and verified the same way on both tracks: the read-only assertion family below proves the one-line clamp over the runtime bridge (GrewEver == false, "ALL MELTED" on screen), a check that fails before the fix and passes after.
  • A language-server client for GDScript and C#. Completion, hover, go-to-definition, find references, rename, and diagnostics โ€” over Godot's LSP (and OmniSharp for C#). Edits are symbol-accurate rather than text-substituted, and type errors surface before the project runs.

Around those, the editing surface is built to be safe to hand to an agent: every edit goes through EditorUndoRedoManager (Ctrl-Z reverts anything the assistant did), destructive tools are confirmation-gated, and every tool result is validated against a frozen output schema. A read-only verification family (assert node state, scene structure, on-screen text, performance baselines, and screenshot diffs) lets the assistant check a running game the way a test would โ€” and because the same server also debugs, a failed assertion is one step from the state that caused it. The editor, LSP, DAP, and runtime bridges are exercised together against a real headless Godot in CI.

It is also secure by default, which is unusual in this field โ€” and the mechanism matters more than the label. A per-project shared secret authenticates every bridge (constant-time, minted into the git-ignored res://.godot/), every socket binds to loopback only, and the highest-blast tools โ€” arbitrary code execution and network egress โ€” are dropped at registration, not merely flagged. They are absent from tools/list until you opt in, so the default surface is 285 tools an agent can actually call, not 298 with a warning label on 13 of them. Destructive operations are confirmation-gated and fail closed on clients that cannot prompt. Nothing runs in the cloud and no project data leaves the machine.

Every tool also publishes MCP risk annotations (readOnlyHint / destructiveHint / idempotentHint / openWorldHint), and breakpoint-mcp tools --json exports the whole surface โ€” so what the server can do, and how risky each tool is, is checkable without running it or guessing from tool names.

When Breakpoint is the right tool โ€” and when it isn't

It earns its keep on work that needs program state or real symbols:

  • Diagnosing a live failure โ€” a wrong value, a null reference, a crash in a signal handler: breakpoint, step, and read the actual variables in the paused frame instead of instrumenting with prints and re-running.
  • Refactoring against real symbols โ€” rename a method or property project-wide, or find every reference, over the LSP, so it's accurate rather than a text search.
  • Type-aware authoring โ€” write GDScript or C# with completion and diagnostics, catching type errors before the game runs.
  • C#/.NET projects โ€” the LSP and DAP paths cover C# as well as GDScript.
  • Verifying a running game in a loop โ€” assert node/scene/screen/performance state after a change, with a failed assertion one step from the debugger.

If you only need scene and script edits from inside the editor โ€” scaffolding a scene, generating a script from a prompt, quick one-shot changes โ€” there are other good alternatives to Breakpoint available in the Godot Asset Library. Breakpoint's value shows up when you need to step through a bug, refactor against real symbols, or work in C#.

How it compares

The field has many capable Godot MCP servers, and it is growing quickly โ€” most cluster on authoring. Breakpoint is deliberately different on the axes that need real program state, real symbols, and a surface that is safe to hand an agent by default:

| Capability | A typical Godot MCP server | Breakpoint | |---|---|---| | Author scenes / scripts, screenshots, read logs | โœ… | โœ… | | Step-debugger (breakpoints, stack, variables, watch) | Some โ€” via Godot's internal editor debugger | โœ… real DAP client; breakpoints proven to stop in CI | | C# step-debugging | โœ— | โœ… over netcoredbg | | Language-server client (completion, rename, references) | Rare | โœ… GDScript and C# | | Runtime verification (assert node/scene/screen/perf, golden-image diff) | โœ— | โœ… runtime_assert_* + runtime_screenshot_diff | | Deterministic playtesting (freeze time, step exact frames, seed RNG, state digest) | โœ— | โœ… frame-exact, verified on 4.3/4.5/4.7 | | Arbitrary code execution in the default surface | Usually present and callable | โœ… absent โ€” dropped at registration until opted in | | Published risk annotations + machine-readable tool export | โœ— | โœ… all 298 tools, CI-enforced | | Undo-safe + schema-frozen results | Rare | โœ… every mutation |

This describes capability classes, not specific projects. Several servers are strong at authoring, some are actively adding debuggers, and if authoring is all you need there are good alternatives in the Asset Library. The tool count is not the axis โ€” ours is 298 because that is what a static contract check asserts, and every one is schema-frozen and annotated.

What the tool surface costs, measured

Breadth is not free, and the honest way to offer it is to publish the bill. These are live measurements of what a tools/list response weighs โ€” produced by host/scripts/token-cost.mjs against the running server, not estimates, and not figures quoted from anyone's README.

What an untouched install advertises is the secure-default surface of 285 tools; opting every higher-trust group in loads the full 298. Two numbers per row, because they are different bills: what the client downloads (tools/list on the wire), and what the model reads โ€” a client hands Claude each tool's name, description and input schema and nothing else.

| | Bytes on the wire | What the model reads | |---|---|---| | Breakpoint, as installed (285 tools) | 370,071 | 213,940 | | Breakpoint, every group opted in (298 tools) | 390,229 | 227,092 | | An authoring-focused server we re-measured (319 tools) | 202,327 | 196,585 |

The second column is measured, not assumed: we captured the request Claude Code 2.1.201 actually builds with Breakpoint attached (pointed at a local capture server; nothing was sent anywhere). Every tool in that capture (1.87.0) arrived as name, description and input schema โ€” no output schema, no risk annotation, no title. So the weight that sets Breakpoint apart on the wire โ€” a frozen outputSchema and a published risk annotation on every tool, which is what lets a client validate a result and lets you audit the surface before you trust it โ€” costs the model's context nothing. Per tool, what Claude reads is about 1.2ร— the leanest alternative we have measured.

In Claude Code, the upfront bill is smaller still. Its default MCP tool search sends only tool names until the model asks for a tool, so a session pays roughly 10 KB for the whole surface and about three-quarters of a kilobyte for each tool it actually loads. The full model-read column is what a client without tool search pays upfront.

And you almost never pay the full bill. Toolsets load only the planes you asked for, so a session that just needs the debugger pays for the debugger โ€” a measured ~86โ€“98% upfront reduction, and it is one environment variable:

BREAKPOINT_TOOLSETS=c        # the runtime plane alone
BREAKPOINT_TOOLSETS=a,b      # editor + CLI

The byte counts are exact (โ‰ˆ tokens at ~3.6 bytes/token, an estimate). Re-derive any row with node host/scripts/token-cost.mjs --summary โ€” it prints both columns โ€” or point it at any other stdio MCP server with --server <cmd> and compare for yourself.

Why a Node host?

Breakpoint runs a small Node process on purpose: it is what lets the server act as a real LSP and DAP client (the two capabilities above), run long jobs on the MCP task model, and connect from any stdio MCP client. The host is the price of the debugger and the language server, not incidental plumbing. Setup is one command to install and one to verify:

npx breakpoint-mcp init     # copies + enables the addon and writes your MCP-client config
npx breakpoint-mcp doctor   # verifies the Godot binary and all four bridges are live
npx breakpoint-mcp --version  # the installed version โ€” quote this in a bug report

If you never step through a bug or refactor against real symbols, you may not need the host; if you do, that is exactly what it buys.

What it does

Breakpoint MCP is organized into four capability planes (full 298 tools, or 285 with the privileged capability group off by default โ€” see Safety & trust model โ€” plus 6 resources):

  • Plane A โ€” Live Editor Bridge (toolset a โ†’ 148 tools: editor_*, scene_*, node_*, signal_*, resource_*,

Truncated for display โ€” read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars10
CategoryDevelopment
Updated3d ago
Forks2

Languages

Python

Trust signals

92/100

From repository metadata: license, adoption, age and documentation. Not a code audit โ€” see the Safety scan above for what the skill file itself contains.

1 low1 info
godot-breakpoint-mcp โ€” MCP Server: Install & Safety Check | SkillAgent