# glade-mcp [Health: Active]

**Category:** 🎮 Gaming  
**Repository:** https://github.com/Glade-tool/glade-mcp  
**GitHub Stars:** 201  
**Views:** 5  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/glade-mcp

## Description
Control the Unity and Godot editors from AI clients: scenes, scripts, physics, materials.

## Tools
Capabilities this server exposes over MCP:

- **request_user_input** — Ask a clarifying question when critical ambiguity blocks progress. Use 2-4 meaningful options. Use multi-select only when multiple selections can all apply.
- **get_session_summary** — List every mutation made this Unity session grouped by category (scripts, materials, gameObjects, components, etc.) with a timeline. Use to answer 'what did you just do' / 'what changed' without re-reading scene state. Read-only.
- **think** — Reason about a complex multi-step task before executing it. Use to plan what objects/assets/scripts to create, in what order (scripts before add_component), and what positions/configurations are needed. Does not modify anything.
- **get_scene_hierarchy** — List GameObject paths in the active scene. Results are capped and BFS-balanced — use find_game_objects (nameContains/hasComponent/tag) or list_children to drill into a specific subtree instead of raising maxResults. For per-object components/state, follow up with get_gameobject_info or get_gameobject_components.
- **get_gameobject_info** — Get detailed information about a GameObject: position/rotation/scale, components, materials (with path and shaderName), and component-specific data (e.g., terrain data). Use to inspect properties or find a reference object's position before calculating offsets.
- **find_game_objects** — Find GameObjects in the scene by name, tag, layer, or component type. Returns a list of matching GameObject paths.
- **get_selection** — Get the currently selected GameObjects in the Unity Editor. Returns paths to all selected objects.
- **set_selection** — Set the Unity Editor selection to specific GameObjects by path. WARNING: This selects objects in the Project window (prefabs/assets) OR scene. If you select a prefab/asset, you CANNOT use it with tools that require scene GameObjects (like get_gameobject_info, set_transform, etc.). Only use set_selection for scene objects that exist in the hierarchy. To work with prefabs, you must instantiate them first with create_game_object or instantiate_prefab.
- **get_unity_console_logs** — Read Unity Editor runtime/play-mode console entries (Debug.Log, runtime exceptions, MonoBehaviour errors). Returns up to 2000 entries. NOT for verifying script compilation — compile_scripts already returns errorCount + per-error file/line/source-context. Calling this after a clean compile (errorCount=0) is forbidden. Valid uses: (a) compile_scripts returned errorCount>0 AND you need extra runtime context, (b) a non-compile tool returned an error you must debug, (c) the user explicitly asked to check the console / read the logs.
- **refresh_asset_database** — Refresh the AssetDatabase.
- **open_scene** — Open a scene in the editor.
- **save_scene** — Save the current active scene.
- **create_game_object** — Create an EMPTY GameObject with no mesh, no collider, no visual representation — only a Transform. Use ONLY for invisible logic-only nodes / hierarchy parents (e.g. 'GameManager', 'EnemySpawner', empty pivots). For ANY visible scene object (player capsule, enemy, prop, platform, ground), use create_primitive instead — create_game_object on a visible object produces an invisible Transform with no body and the user will see nothing in the Game view.
- **create_primitive** — Create a VISIBLE primitive GameObject (Cube, Sphere, Capsule, Cylinder, Plane, Quad) at origin — comes with MeshFilter + MeshRenderer + Collider attached so it shows up in the Game view immediately. Use this for ANY visible scene object: player capsules, enemies, platforms, props, ground planes, level geometry. Do NOT use create_game_object for visible objects — that produces an empty invisible Transform. Follow up with set_transform for non-origin positioning and create_material + assign_material_to_renderer for non-default colors.
- **destroy_game_object** — Destroy a GameObject from the scene
- **set_game_object_active** — Set a GameObject's active state (enable/disable)
- **set_game_object_parent** — Reparent a GameObject — make it a child of another GameObject (or move it to the scene root). Use this for any 'attach X to Y', 'parent X under Y', 'put X inside Y', or hierarchy-restructuring request. NOT related to IK/animation rigging.
- **duplicate_game_object** — Duplicate a GameObject in the scene. Returns the path to the new duplicate.
- **rename_game_object** — Rename a GameObject in the scene.
- **list_children** — List children of a GameObject. Returns paths to child objects.
- **set_layer** — Set the layer of a GameObject (and optionally its children).
- **set_tag** — Set the tag of a GameObject. The tag must already exist in the Tag Manager.
- **snap_to_ground** — Snap one or more GameObjects to the ground by raycasting down. Use this tool when objects need to be adjusted to ground level (e.g., objects are floating or positioned incorrectly).
- **align_objects** — Align multiple GameObjects along a specified axis. Aligns to the min, center, or max bound of the target or first object.
- **group_objects** — Create a new empty parent GameObject and parent the specified objects under it. Useful for organizing scene hierarchy.
- **set_transform** — Set world position/rotation/scale of a SINGLE GameObject. Required after create_primitive when positioning is specified. Use get_gameobject_info to find a reference object's position, then calculate and set the target. For TWO OR MORE objects use set_transform_batch instead — one batch call beats N sequential ones on both latency and cost.
- **set_local_transform** — Set local transform (position, rotation, scale) of a GameObject relative to its parent. REQUIRED when requests specify positioning relative to a parent. Use get_gameobject_info to find reference positions, then calculate target positions. Use 'set' for absolute values, 'add' to offset from current, 'multiply' to scale current values. Always call this after create_primitive/create_game_object when positioning is specified in the request.
- **set_transform_batch** — Apply transforms to MULTIPLE objects in ONE call — always prefer this over repeating set_transform when positioning, rotating or scaling more than one object. THE tool for laying out a scene: a row/grid/circle of platforms, scattering props, spacing waypoints, arranging spawn points, positioning a set of coins or enemies. Each entry takes the same args as set_transform (gameObjectPath, position/rotation/scale as 'x,y,z', operation set|add|multiply). Measured in production: turns that positioned objects one at a time spent 48-56 sequential round-trips where a single batch call would do — that is minutes of the user's time and a large multiple of the cost. If you are about to call set_transform a second time in the same turn, batch the rest instead.
- **get_gameobject_components** — List components on a specific GameObject. Returns component names and missing script count. If you need Inspector-visible component fields, call get_component_inspector_properties after this.
- **get_component_inspector_properties** — Read Inspector-visible serialized properties from a component on a GameObject. Use this after get_gameobject_components when you need the same fields shown in the Inspector. Names use displayName; internalName/path are included for exact matching.
- **add_component** — Add a component to a GameObject. Verify the GameObject exists in the scene hierarchy (check Unity context). For script components, ensure the script has been compiled first.
- **remove_component** — Remove a component from a GameObject
- **set_component_property** — Set a property on a built-in Unity component (Rigidbody, MeshRenderer, Light, Camera, etc.). Supports primitives, Vector3/Color/Quaternion, enums (provide name as string), and asset references (provide asset path). For scene object references, use set_object_reference. Use appendToList=true for List<T>/arrays.
- **set_script_component_property** — Set a property on a custom script component (MonoBehaviour) on a GameObject, found by script name (flexible matching). For built-in components, use set_component_property instead. Supports primitives, Vector3/Color/Quaternion, enums, and asset references. Use appendToList=true for List<T>/arrays.
- **set_object_reference** — Set an object reference field on a component. Use ONLY for built-in Unity components and prefab setup — NOT for runtime script fields. Scripts must be self-contained and find their own references via Start()/Awake().
- **create_tilemap** — Create a Grid + Tilemap + TilemapRenderer — the foundation for tile-based 2D levels (platformers, top-down RPGs). Returns gridPath and tilemapPath. Call again with gridPath to stack more layers (background / foreground / hazards) on the same grid. Paint it with set_tilemap_tiles, then make it solid with add_tilemap_collider_2d.
- **set_tilemap_tiles** — Paint or erase tiles on a Tilemap (pairs with create_tilemap). Cells are TILE units, not world units: list them as 'x,y;x,y;...' and/or fill a rectangle with fillRect 'x,y,w,h'. Pass a Tile asset (tilePath) or just a sprite (spritePath, plus spriteName for a sliced sheet) — a reusable Tile asset is created next to the sprite automatically. Set erase=true to clear the listed cells instead.
- **add_tilemap_collider_2d** — Make a painted Tilemap SOLID so 2D physics bodies can stand on it. A tilemap is purely visual until this runs — a Rigidbody2D player falls straight through the floor. composite=true merges per-tile boxes into clean outlines (prevents ghost-collision seams between tiles; recommended for level geometry). oneWay=true makes platforms the player can jump up through and land on.
- **create_script** — Create a new text-based asset file (.cs, .shader, .compute, .hlsl, etc.). Extension determines asset type. Use when the file does NOT exist; use modify_script if it already exists. IMPORTANT: After creating a .cs script, you MUST call compile_scripts and wait for status='idle' BEFORE calling add_component with the new type — otherwise the type won't be found. SAFETY: the bridge refuses create_script when the target path already exists on disk and was not created in this session via create_script, unless confirmExistingFileModification=true is set. Set the flag ONLY when the user explicitly named the file to regenerate or replace. Otherwise pick a different path — never silently clobber existing user code.
- **modify_script** — Modify an existing text-based asset file (.cs, .shader, .compute, etc.). File MUST exist — verify in Unity context first. TWO MODES: (1) SURGICAL EDIT (preferred for anything but a near-total rewrite) — pass oldString + newString to replace one exact snippet, leaving the rest of the file untouched. Far cheaper and safer on large files than resending the whole thing. (2) FULL REWRITE — pass scriptContent with the complete file. SAFETY: the bridge refuses modify_script against scripts the agentic loop did NOT create in this session unless confirmExistingFileModification=true is set. Set the flag ONLY when the user explicitly named the file (e.g. 'update PlayerMovement.cs') or used language like 'extend' / 'modify the existing X'. Absent that signal, do NOT set the flag and do NOT call modify_script — call create_script with a new path for fresh-scaffold prompts.
- **get_script_content** — Read a text-based asset file by path (e.g., 'Assets/Scripts/PlayerMovement.cs', 'Assets/Shaders/MyShader.shader'). Supports .cs (C# scripts), .shader (HLSL/CG shaders), .compute (compute shaders), .hlsl, .cginc, and other text-based Unity assets. Reads the WHOLE file by default. For a LARGE C# file, prefer outline=true FIRST to get its structure (types + methods + properties with line numbers) cheaply, then pass startLine/endLine to read only the member you need instead of loading thousands of lines into context — the response always includes totalLines so you know how much you didn't read. Use this when the user asks to fix or update a specific script or shader.
- **find_scripts** — Find scripts by name (returns script paths). Use when you need to locate a script by partial name before reading it.
- **find_references** — Find every script that references a symbol (a class, method, or field name), with per-file line context. Matches whole identifiers only in CODE — 'Player' does NOT match 'PlayerController', and matches inside string literals ('"Player"') or comments ('// Player') are ignored, unlike the raw substring search_scripts. ALWAYS call this BEFORE renaming, changing the signature of, or refactoring a public class/method/field — it reveals the dependent scripts a change would break so you can update them too (or use rename_symbol to update them all at once). Returns files ordered by reference count (heaviest dependents first). totalFileCount / totalMatches report the TRUE project-wide blast radius even when line detail is capped at maxFiles, and truncated=true means more files reference the symbol than were returned — raise maxFiles (or update the returned files first, then re-run) so you don't refactor against a partial picture.
- **find_component_usages** — Find every prefab asset and open-scene GameObject that has a component of a given type — the Inspector-WIRING counterpart to find_references (which covers code). Use it to see the blast radius BEFORE removing/renaming a MonoBehaviour or changing a component: the scenes/prefabs where it's attached are invisible in the source because that wiring lives in scene/prefab data, not scripts. Accepts a script class name ('PlayerController') or a built-in component ('Rigidbody', 'BoxCollider'). Returns each usage as {location: 'scene'|'prefab', container, gameObject, componentType}.
- **compile_scripts** — Check Unity script compilation status. Call this after create_script or modify_script. Returns isCompiling (bool) and status ('compiling' or 'idle'). If still compiling, call again. When compilation finishes with errors, returns hasErrors=true plus each error's file path, line number, and ±10 lines of source context — use that context to fix the script before retrying.
- **create_folder** — Create a folder in the Assets directory. Creates parent folders if needed.
- **move_asset** — Move an asset to a new location in the project.
- **delete_asset** — Delete an asset from the project. Use with caution!
- **list_assets** — List assets in the project by type and/or name filter. Use nameContains to narrow results. Returns filenames in message.
- **check_asset_exists** — Check if an asset exists at a path (case-insensitive). Returns similar paths if not found. When false, immediately call the corresponding create tool in the same response — this is a verification step, not a stopping point.
- **create_prefab** — Create a prefab from a GameObject in the scene
- **instantiate_prefab** — MANDATORY: You MUST verify the prefab exists FIRST using check_asset_exists before calling this tool. If the prefab doesn't exist, create it with create_prefab first. Instantiate a prefab into the scene.
- **get_prefab_info** — Get information about a prefab asset, including hierarchy, components, and transform properties. Use this to inspect prefab structure before editing.
- **create_material** — Create a new Material asset. Check system prompt for 'ACTIVE RENDER PIPELINE' to pick the right shader: URP='Universal Render Pipeline/Lit', HDRP='HDRP/Lit', Built-in='Standard'. After creating, call assign_material_to_renderer to apply it.
- **set_material_property** — Set a property on a Material asset. For base color: '_BaseColor' (URP/HDRP) or '_Color' (Built-in). Check the system prompt for active render pipeline. Use list_materials to find the path if needed. If material is shared, consider creating a new one instead.
- **assign_material_to_renderer** — Assign a Material to a GameObject's Renderer. Call after create_material. Verify existing materials exist with check_asset_exists first.
- **list_materials** — List all Material assets in the project. Returns a list of material paths. Use this to find existing materials before creating new ones, or when you need to find a material by name (e.g., if user says 'change the blue material', use searchPattern='blue' to find it).
- **change_material_shader** — Change a material's shader to a different shader. Automatically preserves common shader properties (color, textures, metallic, smoothness) when converting between similar shaders. CRITICAL: Check system prompt for active render pipeline and use appropriate shader names.
- **create_light** — Create a new Light GameObject in the scene.
- **set_light_properties** — Set properties on a Light component.
- **set_render_settings** — Configure global render settings for the scene (fog, ambient lighting, skybox).
- **create_audio_source** — Create a new GameObject with an AudioSource component.
- **set_audio_source_properties** — Set properties on an AudioSource component.
- **assign_audio_clip** — Assign an AudioClip asset to an AudioSource component.
- **create_animator_controller** — Create a new Animator Controller asset.
- **add_animator_parameters** — Add parameters to an Animator Controller.
- **add_animator_state** — Add a state to an Animator Controller layer with an animation clip. After creating states, call add_animator_transition and add_animator_transition_conditions to wire up logic.
- **add_animator_transition** — Add a transition between animator states. After creating, call add_animator_transition_conditions to add conditions (transitions without conditions fire immediately). hasExitTime=false for locomotion; hasExitTime=true + exitTime=0.9 for attacks/jumps returning to idle.
- **assign_animator_controller** — Assign an Animator Controller to a GameObject's Animator component.
- **create_collider** — Add a collider to a GameObject. Types: Box (walls/floors), Sphere (balls), Capsule (characters — auto-detects axis), Mesh (static exact shape), Convex (mesh + Rigidbody), Wheel (vehicles), Terrain. Auto-aligns to mesh bounds unless size/center/radius/height is provided. Checks for CharacterController/duplicate conflicts; warnings in response.
- **set_collider_properties** — Update collider properties on a GameObject. Works for all types (Box, Sphere, Capsule, Mesh, Wheel, Terrain). Response includes conflict warnings for CharacterController or multiple colliders.
- **create_character_controller** — Add a CharacterController to a GameObject. Auto-removes existing colliders (CharacterController has its own built-in capsule collider). Auto-aligns to mesh bounds unless radius/height/center provided. Set keepExistingColliders=true to prevent auto-removal. Use for player movement; use Rigidbody for physics-based movement.
- **add_rigidbody** — Add a Rigidbody to a GameObject. Checks for existing Rigidbody, CharacterController conflicts, and missing colliders. Use Rigidbody for physics-based movement; do NOT combine with CharacterController on the same object.
- **set_rigidbody_properties** — Update properties on a Rigidbody. Response includes warnings if CharacterController is also present.
- **create_physics_material** — Create a PhysicMaterial asset. Defines friction and bounciness for colliders. Assign to colliders via assign_physics_material. Returns error if asset already exists at path.
- **add_rigidbody_2d** — Add a Rigidbody2D — the 2D physics body for platformer characters, falling crates, projectiles. 2D and 3D physics are SEPARATE simulations: a Rigidbody2D never collides with 3D colliders, so pair it with create_collider_2d shapes. bodyType: 'dynamic' (gravity + forces), 'kinematic' (script-driven motion), 'static' (immovable). Set freezeRotation=true for characters so they don't tip over — the #1 2D beginner surprise. Unity blocks 2D physics on objects carrying 3D physics components; the tool refuses with the blocker named.
- **create_collider_2d** — Add a Collider2D. Types: Box (crates/platforms), Circle (balls/coins), Capsule (characters — slides smoothly over steps), Polygon (traces the sprite's outline), Edge (thin ground line from a point list). Box/Circle/Capsule auto-fit the attached sprite's bounds unless size/radius is given. 2D colliders only interact with 2D physics — pair with add_rigidbody_2d for moving bodies; static level geometry needs no Rigidbody2D. Unity blocks 2D physics on objects carrying 3D physics components; the tool refuses with the blocker named.
- **look_at_game_view** — Capture a screenshot of the rendered game view so you can SEE the current scene and verify it visually. Use this to check your own work after building or changing visuals — it catches problems node/component inspection cannot: invisible or missing objects, wrong/pink materials, off-screen or clipped UI, bad lighting (too dark/blown out), and poor framing. The image is returned to you as a vision input. Renders the active game camera (works in edit mode). Call it when the user asks you to 'look at', 'check how it looks', or to fix a visual issue, and to confirm a visual change had the intended effect.
- **create_camera** — Create a Camera GameObject. For follow/third-person cameras, create a Camera + movement script. For advanced cinematic cameras with blending, use create_cinemachine_virtual_camera instead (requires Cinemachine package).
- **set_camera_properties** — Update Camera properties on a GameObject including HDR and MSAA settings.
- **create_canvas** — Create a Canvas with scaler and raycaster. Requires TextMeshPro (auto-installed if missing).
- **create_ui_element** — Create a UI element (Panel, Text/TMP, Image, Button, Slider, Toggle, Dropdown, InputField, ScrollView, LayoutGroup, etc.). Requires TextMeshPro. Always specify contrasting colors (white text on dark panels, dark text on light panels). For health bars, use type='Filled' with fillMethod='Horizontal'.
- **import_tmp_essential_resources** — Import TextMeshPro Essential Resources if not already present (checks Assets/TextMesh Pro/Resources). TMP package presence in Unity context does not mean Essential Resources are imported — trust this tool's response, not the context.
- **create_event_system** — Create an EventSystem if one does not exist.
- **start_runtime_observation** — Arm Live Loop runtime observation. Snapshots the current runtime-event cursor so subsequent get_runtime_events polls return only new errors. Idempotent — safe to call after a reconnect to refresh the baseline. Returns startCursor + isPlaying.
- **stop_runtime_observation** — Disarm Live Loop runtime observation. The bridge keeps recording events; this just signals the runner is no longer interested. Use when ending a session or explicitly halting the loop.
- **get_runtime_events** — Pull runtime errors / exceptions captured since sinceCursor. Read-only. Returns events[] (each with cursor, message, stackTrace, logType, timestamp, fingerprint), nextCursor, playModeActive, observationActive, lastTransition. Pass the previous response's nextCursor on the next poll. When playModeActive is false, the runner should stop polling.
- **get_play_mode_state** — Get Unity Play Mode state. Read-only. Returns isPlaying, willChangePlayMode, lastTransition, last enter/exit timestamps, observationActive, observationStartCursor. Use to detect Play exit (so queued fixes can be applied) and Play re-entry during APPLYING.
- **apply_queued_fix** — Apply a Live Loop FixProposal by dispatching each change through the existing tool dispatcher. Idempotent: a second call with the same proposalId returns alreadyApplied:true with the prior result and does NOT re-execute. Use after Play exits or the user accepts a proposed fix.
- **find_asset** — **Search-only — returns previewable candidates; does NOT install anything.** ALWAYS use this tool — not web search — when the user asks to find, download, search for, or import any game asset: art, sprites, 2D/3D models, audio, SFX, music, UI icons, tilesets, platformer art, character art, etc. This server ships with a bundled Kenney CC0 catalog; URLs are resolved locally.

AFTER find_asset RETURNS — reply in ONE SHORT SENTENCE:
  • Name the top match: 'Top match: <name> (<license>).'
  • If the user's initial message included 'and import' or 'import it' or similar intent, ALSO add: 'Want me to import it?' — then wait for confirmation.
  • Otherwise just name the top match and stop. The user will say which one.

DO NOT:
  • Claim inability to download. import_asset performs the download itself; you do not need a local file. Writing 'I can't fetch a pack from the internet' or 'please provide the file' is wrong — that's exactly what import_asset does.
  • Auto-call import_asset before the user confirms which one.

v0 providers: Kenney (CC0 game asset packs).
- **import_asset** — **Downloads, installs, and configures an external asset in the Unity project.** No local file is required — the bridge fetches the asset over HTTPS from the provider's official host, extracts archives, places everything under Assets/, configures Unity import settings per asset_type, and writes a license sidecar. The download URL is resolved locally from the bundled catalog; you don't and can't supply it.

Use this for any candidate returned by find_asset. The candidateId fully identifies the asset.

REQUIRED LICENSE GATE: licenseAcknowledged MUST be true. Set it to true only after the user has explicitly accepted the license shown in the prior find_asset result (e.g. they said 'import it', 'yes', 'go ahead').
- **list_imported_assets** — List assets imported through the asset pipeline in this project, with their license metadata. Read-only. Use before commercial release to audit attribution requirements (CC-BY assets need credit; CC0 does not). Reads .gladekit-asset.json sidecars.
- **get_relevant_tools** — Given a Unity task description, returns the most relevant tools for that task — including extended tools beyond the core listed set. Call this before starting specialized work (animator blend trees, navmesh, IK, terrain, particle systems, cinemachine, etc.) to discover the right tool names. Extended tools are callable even though they don't appear in the tool list.
- **remember_for_session** — Store a fact or piece of context for the current session. Use this to remember project-specific details, user preferences, or intermediate findings that you'll need to reference later in this conversation. Facts are stored in memory for the lifetime of this MCP session only.
- **recall_session_memories** — Retrieve all facts stored with remember_for_session during this session. Call this to recall project context you captured earlier in the conversation.
- **batch_execute** — Execute multiple tool calls in a single request to Unity. Reduces round-trip overhead for multi-step operations like create object → set transform → add component → create material → assign material. Each call runs sequentially on the Unity main thread. Returns per-call results with individual success/failure status — partial failures do not abort the batch.
- **search_project_scripts** — Semantically search project scripts by relevance to a query. Returns the top matching scripts ranked by cosine similarity. Requires OPENAI_API_KEY — not currently set, will return unranked results.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "glade-mcp": {
    "command": "uvx",
    "args": ["gladekit-mcp"]
  }
}
```

## Documentation

## What glade-mcp does

glade-mcp lets AI clients operate a running Unity or Godot editor through MCP. It supports both engines from one server and selects the appropriate tool set by probing the local editor bridges. Unity 2021.3 and later is supported, while Godot support targets version 4.3 and later.

For Unity, the repository describes 275 tools covering 20 categories. Godot provides 115 native tools across 17 categories. The broader feature set includes scene and node editing, scripts, resources, physics, signals, 2D and 3D workflows, animation, audio, UI, navigation, runtime operations, project inspection, and build or export tasks.

The listed Unity tools cover practical scene operations such as opening and saving scenes, creating primitives or empty hierarchy nodes, finding and inspecting GameObjects, changing transforms, parenting, grouping, tagging, layering, selecting, duplicating, renaming, activating, and deleting objects. They also expose component inspection, material-related state, console logs, asset database refreshes, and session mutation history.

## How it works

Each editor uses a local bridge. Unity listens on `localhost:8765`; Godot listens on `localhost:8766`. When the MCP process starts, it checks both ports and exposes the tools belonging to the detected engine. Set `GLADEKIT_MCP_FORCE_ENGINE` to `unity` or `godot` when both editors are running and the choice needs to be fixed.

The MCP client launches the server through stdio, typically with `uvx gladekit-mcp`. The editor bridge remains responsible for applying operations inside the IDE. Godot creates a per-session authentication token under `~/.gladekit/godot-bridge-8766.token`, which the MCP server reads automatically.

Planning and inspection tools support multi-step work. `think` is read-only and helps organize dependencies such as creating scripts before attaching components. `get_session_summary` reports mutations made during the current Unity session, while scene and component queries provide state for subsequent edits. `set_transform_batch` handles multiple object transforms in one call for layouts such as rows, grids, circles, and scattered objects.

## Setup and configuration

Install the bridge for the engine being used. In Unity, add the `unity-bridge` package from the repository through Package Manager using its Git URL. In Godot, install the released bridge archive or copy the addon into the project’s `addons/` directory, then enable **GladeKit MCP Bridge** under Project Settings → Plugins.

Install `uv`, then add a stdio MCP server entry using `uvx gladekit-mcp`. Configuration examples are provided for Claude Code, Cursor, Claude Desktop, Cline, Windsurf, and VS Code. Unity 6000.3 or later can also connect through its AI Gateway when the AI Assistant package is installed.

## Tools and capabilities

- Inspect scene hierarchies, selections, GameObjects, components, serialized Inspector properties, and Unity console entries.
- Create visible Unity primitives or invisible hierarchy nodes, then position, rotate, scale, parent, group, duplicate, rename, activate, tag, layer, or remove them.
- Open and save scenes, refresh the AssetDatabase, snap objects to the ground, align objects, and apply batch transforms.
- Work with scripts, gameplay scaffolding, runtime verification, project introspection, and build or export workflows across the supported engines.
- Use clarification, planning, and session-summary tools to manage ambiguous or multi-step editor changes.

## Limitations and notes

Godot support is for GDScript projects using Forward+ or Compatibility renderers in 2D or 3D. Godot Mono and C# projects are not supported. The Godot bridge operates only in the editor and does not run in exported games.

Unity’s scene hierarchy results are capped and breadth-balanced, so deeper inspection may require narrowing the search with `find_game_objects` or `list_children`. `set_transform` handles one object; multiple objects should use `set_transform_batch`. `get_unity_console_logs` is intended for runtime or debugging context and is not the tool for confirming script compilation; compilation results come from `compile_scripts`.

_Full upstream README: https://allmcps.com/mcp/glade-mcp/readme_