What can you do with this server?

Patina Unity MCP lets you control the Unity Editor directly from any MCP-compatible AI assistant via three core tools that expose 86 Unity commands. Core MCP Tools * patina_capabilities – Browse and search the Unity command catalog by category, name, or keyword; optionally fetch parameter schemas before calling a command * patina_call – Execute any of the 86 cataloged Unity commands with JSON parameters * patina_health – Check server version, bridge port, command count, and optionally query live Unity editor state What You Can Do (via patina_call) * Scene Management – Get hierarchy, open/save/create scenes, query scene info and stats * GameObject Operations – Create primitives, delete, duplicate, reparent, show/hide, set tags/layers/transforms * Components & Properties – Add/remove components, read/write serialized properties * Batch Operations – Apply transform changes, property edits, or component additions to multiple GameObjects at once * Prefabs – Create, instantiate, inspect, unpack, apply/revert overrides, edit prefab assets * Assets – Find by type or name, get metadata, create folders, move/rename/delete assets, refresh the Asset Database, set labels * Materials – Create materials, read/write shader properties, assign materials to renderers * Scripts – Create C# scripts, read script content, trigger recompilation, get compiler errors * Scriptable Objects – Read and write serialized fields on ScriptableObject assets * Search & Query – Find GameObjects by tag, component, layer, hierarchy path, or compound filters * Console – Log messages, read buffered console entries, clear the console * Editor Control – Get editor state, read project settings, enter/exit/pause play mode, execute menu items, manage selection * Undo/Redo – Open/close undo groups, perform undo/redo steps, inspect the undo stack * Build & Player Settings – Read/write build settings, scene list, player settings, and switch build targets * Test Runner – Run Unity tests, retrieve results, list available tests * Animation – Inspect Animator controllers, set parameters at runtime, list animation clips * Validation – Scan scenes and assets for missing scripts, broken references, and null serialized fields

Which integrations are available for this server?

Controls the Unity Editor by providing tools for scene management, GameObject manipulation, asset operations, script handling, and more, allowing AI agents to interact with Unity directly.

Patina Unity MCP

by taygunsavas

Overview Schema Source Related Servers Score Discussions Admin

Local

Patina Unity MCP lets you control the Unity Editor directly from any MCP-compatible AI assistant via three core tools that expose 86 Unity commands.

Core MCP Tools

patina_capabilities – Browse and search the Unity command catalog by category, name, or keyword; optionally fetch parameter schemas before calling a command
patina_call – Execute any of the 86 cataloged Unity commands with JSON parameters
patina_health – Check server version, bridge port, command count, and optionally query live Unity editor state

What You Can Do (via patina_call)

Scene Management – Get hierarchy, open/save/create scenes, query scene info and stats
GameObject Operations – Create primitives, delete, duplicate, reparent, show/hide, set tags/layers/transforms
Components & Properties – Add/remove components, read/write serialized properties
Batch Operations – Apply transform changes, property edits, or component additions to multiple GameObjects at once
Prefabs – Create, instantiate, inspect, unpack, apply/revert overrides, edit prefab assets
Assets – Find by type or name, get metadata, create folders, move/rename/delete assets, refresh the Asset Database, set labels
Materials – Create materials, read/write shader properties, assign materials to renderers
Scripts – Create C# scripts, read script content, trigger recompilation, get compiler errors
Scriptable Objects – Read and write serialized fields on ScriptableObject assets
Search & Query – Find GameObjects by tag, component, layer, hierarchy path, or compound filters
Console – Log messages, read buffered console entries, clear the console
Editor Control – Get editor state, read project settings, enter/exit/pause play mode, execute menu items, manage selection
Undo/Redo – Open/close undo groups, perform undo/redo steps, inspect the undo stack
Build & Player Settings – Read/write build settings, scene list, player settings, and switch build targets
Test Runner – Run Unity tests, retrieve results, list available tests
Animation – Inspect Animator controllers, set parameters at runtime, list animation clips
Validation – Scan scenes and assets for missing scripts, broken references, and null serialized fields

Patina

npm version MCP Registry Glama MCP server Indexed on TensorBlock MCP Index License: MIT

Control the Unity Editor from any MCP host. One package install, one click, and your AI assistant can see your scene, create objects, and talk to the console.

Patina is a Rust MCP server paired with a C# Unity bridge. It connects your favorite AI coding tool directly to the Unity Editor over a local TCP channel, with zero manual config.

Why Patina?

One-click setup. Install the UPM package, click a button, and every supported host is configured automatically.
No Rust required. Release packages ship pre-built binaries for Windows, Linux, and macOS. Just install and go.
Built for speed. The Rust sidecar keeps the MCP layer fast and lightweight while Unity stays on the main thread.
Multi-host. Works with Claude Code, Cursor, VS Code, Gemini CLI, JetBrains Rider, Codex CLI, and more.

Related MCP server: Unity-MCP-Vibe

How It Works

MCP Host  <-- stdio -->  Patina Server  <-- local TCP -->  Unity Editor

The host launches the Rust binary over stdio MCP. The Rust server forwards tool calls into Unity through a local loopback TCP bridge. Unity executes them on the main thread and returns the result.

Quick Start

1. Install the Unity package

In Unity, open Project Settings > Package Manager, add a scoped registry, then install the package by name.

Scoped registry:

Field	Value
Name	`npmjs`
URL	`https://registry.npmjs.org`
Scope(s)	`com.taygunsavas`

Then open the Package Manager (Window > Package Manager), click the + icon in the top left, select Add package by name..., and enter:

com.taygunsavas.patina-unity-mcp

Registry releases are signed during the release workflow for Unity Package Manager verification.

Alternatively, open the Package Manager, click the + icon, select Add package from git URL..., and enter:

https://github.com/taygunsavas/patina-unity-mcp.git?path=/unity-package

Patina is distributed as a complete Unity package artifact with the editor code, native Rust runtime binaries under Plugins/<platform>/, and the Unity metadata needed for import. End users do not need the Rust toolchain or a Git checkout of this repository.

2. Run One-Click Setup

Open Window > Patina Unity MCP and click One-Click Setup.

The setup flow verifies the binary, starts the Unity bridge, auto-configures every detected host, replaces stale entries, and shows restart guidance where needed.

Patina writes host configs to a stable user-level runtime path instead of a per-project Unity package cache path. When the package is updated, the Unity editor package refreshes that managed runtime automatically, so supported MCP hosts do not need to be reconfigured just because the package cache path changed.

3. Start building

Open your MCP host and try:

"Log hello to Unity console"
"Show me the scene hierarchy"
"Create a cube at position 0, 2, 0"

Available Capabilities

Patina keeps the advertised MCP surface compact so hosts do not need to load every Unity command schema into context. Agents should use:

MCP tool	What it does
`patina_capabilities`	Search or browse the Unity command catalog; request schemas only for specific commands
`patina_call`	Execute a catalog command with JSON parameters
`patina_health`	Inspect Patina version, command count, bridge port, optional Unity editor state, and bridge diagnostics

The 87 commands below are available through patina_capabilities and patina_call.

Scene

Tool	What it does
`get_hierarchy`	Retrieve the active scene's GameObject tree as nested JSON; supports `max_depth` and `name_filter`
`get_scene_info`	Active scene metadata (name, path, build index, root count, dirty state); pass `include_all_scenes` for all loaded scenes
`open_scene`	Open a scene by project-relative path; `mode` single (default) or additive
`save_scene`	Save the active scene or any loaded scene; supports Save As
`new_scene`	Create and save a new scene with optional empty or default-game-objects setup

GameObjects

Tool	What it does
`create_game_object`	Spawn an empty GameObject or a built-in primitive (Cube, Sphere, Capsule, Cylinder, Plane, Quad)
`delete_game_object`	Permanently delete a GameObject and all its children
`duplicate_game_object`	Duplicate a GameObject and its children
`reparent_game_object`	Move a GameObject under a new parent; pass `null` to promote to scene root
`get_game_object_info`	Full details for a named GameObject: transform, tag, layer, and all component properties
`set_active_state`	Show or hide a GameObject via `SetActive()`
`set_tag`	Set the tag on a GameObject (tag must be registered in Tags & Layers)
`set_layer`	Set the layer by name; optionally apply to all children
`set_transform`	Set position, rotation (Euler), and/or scale in world or local space in one call

Components & Properties

Tool	What it does
`add_component`	Add a component by short name (`Rigidbody`) or fully qualified name
`remove_component`	Remove a component by type name
`set_property`	Set any serialized property on a component using its SerializedObject path
`get_game_object_components`	Return a lightweight component list for a GameObject

Batch Operations

Tool	What it does
`batch_set_properties`	Apply serialized property changes across multiple GameObjects
`batch_add_components`	Add components to multiple GameObjects
`batch_set_transform`	Apply transform changes to multiple GameObjects

Prefabs

Tool	What it does
`create_prefab`	Save a scene GameObject as a prefab asset
`instantiate_prefab`	Instantiate a prefab into the scene at an optional world position
`get_prefab_info`	Inspect a prefab asset or scene instance; returns asset type, overrides list, and instance status
`unpack_prefab`	Sever a prefab instance link; `outermost` (default) or `completely`
`apply_prefab_overrides`	Apply all instance overrides back to the source prefab asset on disk
`revert_prefab_overrides`	Restore a prefab instance to match its source asset
`list_prefab_components`	List component types and instance IDs on a prefab asset; optionally includes child GameObjects with transform paths
`edit_prefab_asset`	Perform a batch of edit operations (add/remove component, add/remove child, set field) on a prefab asset, including object-reference fields
`open_prefab_stage`	Open a prefab asset in Unity's prefab stage for editing; exit using `close_prefab_stage`
`close_prefab_stage`	Close the active prefab stage; `save_changes` parameter resolves dirty stages without Unity's blocking save prompt, giving save or discard decision

Example: Set a component reference within a prefab.

To point a serialized field at another component inside the same prefab, pass an edit_prefab_asset action with set_field and an object reference value. The transform_path inside value is resolved against the prefab root, not against the action's own transform_path:

{
  "asset_path": "Assets/Prefabs/MyPrefab.prefab",
  "actions": [
    {
      "action_type": "set_field",
      "component_type": "MyNamespace.MyComponent",
      "field_name": "targetReference",
      "value": {"transform_path": "Container/Button", "component_type": "MyNamespace.TargetComponent"}
    }
  ]
}

Assets

Tool	What it does
`find_assets_by_type`	Search the Asset Database by type filter (`t:Material`, `t:Prefab`, `t:Texture2D`, etc.)
`find_assets_by_name`	Search the Asset Database by partial name match
`get_asset_info`	Metadata for an asset: GUID, type, file size, labels, and importer settings
`create_folder`	Create a new folder in the Asset Database
`move_asset`	Move an asset to a new project-relative path
`rename_asset`	Rename an asset in-place
`delete_asset`	Delete an asset by project-relative path
`refresh_asset_database`	Trigger `AssetDatabase.Refresh`; incremental or force-reimport
`set_asset_labels`	Replace the full label list on an asset

Materials

Tool	What it does
`create_material`	Create a new Material asset; defaults to URP/Lit
`get_material_properties`	Read all exposed shader properties with names, types, and current values
`set_material_property`	Set a shader property (float, bool, color, vector, or texture path)
`assign_material`	Assign a Material to a specific Renderer slot

Scripts

Tool	What it does
`create_script`	Create a new C# script from a template (`monobehaviour`, `scriptableobject`, `editor_window`, `plain_class`, `interface`) or verbatim content
`resolve_script_type`	Resolve a MonoScript GUID and asset path by its fully qualified C# type
`force_recompile`	Trigger a Unity script recompile via `AssetDatabase.Refresh(ForceUpdate)`
`compile_and_get_errors`	Trigger script recompile and return compiler errors only; also returns `compilationRan`, `domainReloadObserved`, and `reloadCount`
`get_compilation_errors`	Get the list of current compiler errors and warnings
`get_script_content`	Read the content of a script file in the project
`get_assembly_types`	List all types declared in a specific assembly
`request_script_reload`	Request a domain reload via `EditorUtility.RequestScriptReload()` and return once it completes, enabling observation of reload-time errors

Scriptable Objects

Tool	What it does
`get_scriptable_object`	Read serialized fields from a ScriptableObject asset
`set_scriptable_object_field`	Set one serialized ScriptableObject field

Validation & Health

Tool	What it does
`validate_scene`	Scan the active scene for quality issues (missing script references, null serialized fields, and broken prefab connections)
`validate_assets`	Validate a single prefab asset or a folder recursively for missing scripts, broken object references, and unassigned required serialized fields
`get_scene_stats`	Return lightweight statistics for the active scene (object count, component count, unique type counts, max depth, etc.)

Search & Query

Tool	What it does
`find_game_objects_by_tag`	Find all active GameObjects with a given tag
`find_game_objects_by_component`	Find all scene objects that have a given component type
`find_game_objects_by_layer`	Find all scene objects on a given layer by name
`query_game_objects`	Find GameObjects matching compound filters
`find_game_objects_by_path`	Find GameObjects by hierarchy path prefix

Console

Tool	What it does
`log_to_console`	Emit a message to the Unity Console (`info`, `warning`, or `error`)
`get_console_logs`	Read buffered console entries with per-entry `phase` field (`normal`, `reloadTeardown`, `reloadStartup`); filterable by type, capped by `max_results`; includes `reloadWindowEntryCount`
`clear_console`	Clear all console log entries

Editor State & Control

Tool	What it does
`get_editor_state`	Current editor flags and main-thread responsiveness; returns a limited blocked state with `blockedByModalDialogLikely` if Unity is not processing editor updates
`get_project_settings`	Read-only snapshot of key project settings (version, build target, color space, physics gravity, etc.)
`set_play_mode`	Enter, exit, pause, unpause, or step play mode
`execute_menu_item`	Execute any Editor menu item by full path (e.g. `Assets/Refresh`)
`get_selection`	Return the current Editor selection (scene objects and/or asset paths)
`set_selection`	Set the Editor selection to specific GameObjects and/or asset paths

Undo

Tool	What it does
`begin_undo_group`	Open a named Unity Undo group
`end_undo_group`	Collapse operations into the current Undo group
`undo`	Perform one or more Undo steps
`redo`	Perform one or more Redo steps
`get_undo_stack`	Return current Undo and Redo stack entry names

Build & Player Settings

Tool	What it does
`get_build_settings`	Build Settings snapshot: active target, scripting backend, and full scene list
`set_build_scenes`	Replace the Build Settings scene list with an ordered list of scene paths
`get_player_settings`	Read Player Settings for a build target group (Standalone, Android, iOS, WebGL)
`set_player_settings`	Write Player Settings fields; only non-null fields are changed
`set_build_target`	Switch the active build target (blocks the main thread on large projects)

Test Runner

Tool	What it does
`run_tests`	Start a Unity Test Runner execution
`get_test_results`	Return results from the most recent test run
`get_test_list`	List available Unity tests

Animation

Tool	What it does
`get_animator_info`	Read Animator Controller parameters and state information
`set_animator_parameter`	Set an Animator parameter in play mode
`list_animation_clips`	List AnimationClip assets in the project

Supported Hosts

Host	Setup
Antigravity CLI (agy)	Automatic
Claude Code (Anthropic CLI)	Automatic (`~/.claude.json`)
Claude Desktop	Automatic
Cursor	Automatic
Visual Studio Code	Automatic
GitHub Copilot (VS Code)	Linked via VS Code config
Gemini CLI	Automatic
JetBrains Rider / Junie	Automatic
Codex CLI	Automatic

The setup window also detects stale entries, missing hosts, and provides a clean Remove Patina From Hosts action.

Troubleshooting

If a Patina call reports EDITOR_BLOCKED, or mentions that Unity may be waiting on a modal dialog, check the Unity Editor for a save-changes prompt or other blocking popup. Patina cannot safely run queued editor commands while Unity is waiting for user input. Resolve the Unity prompt, then retry the MCP command or run patina_health with {"include_unity_state": true}.

Prefab Stage Save Dialogs

Patina addresses dirty prefab stages by responding to the save question programmatically rather than blocking on a modal. When you call close_prefab_stage, the save_changes parameter directly determines the outcome: true saves, false (default) discards changes. This applies only to that command call and does not alter Editor behavior when a human is working manually.

Once a modal dialog appears, Unity's main thread is blocked and remains blocked until a human closes it. Every queued command processes through the same blocked thread, so prevention is the only real solution. For agent-written editor scripts, the safe pattern is to write prefabs using PrefabUtility.LoadPrefabContents, apply changes to a SerializedObject, save with PrefabUtility.SaveAsPrefabAsset, then PrefabUtility.UnloadPrefabContents. This approach never opens a prefab stage. If a stage must be opened, close it with close_prefab_stage. Leaving a dirty stage and manually calling StageUtility.GoToMainStage() will lock the Editor.

Unity offers a startup flag, -automated, which disables dialogs process-wide. While this may be suitable for an Editor driven entirely by agents, it creates problems in hybrid workflows where a human and agent share the same Editor: unsaved changes trigger no prompts, and some operations silently cancel. Patina does not require -automated. Per-command dialog answering works reliably without it and behaves correctly even in an Editor opened with -automated.

To check the current Editor state and dialog automation status, call patina_health and examine broker.sessions[].automated in the default output, or isAutomatedMode and dialogAutomationAvailable when passing {"include_unity_state": true}.

Roadmap

Phase	Focus
Phase 1 ✓	Core tools: console, hierarchy, object creation
Phase 2 ✓	Expanded coverage: scene management, asset operations, component editing
Phase 3 (current)	Distribution and reach: Git URL installation docs, package layout, release pipeline

Local Development

Contributor source checkout

Use this when you are editing unity-package/ or rust-server/ directly from the repository:

Point Unity at the local package checkout.
- file:<your-clone-path>/unity-package
Build the Rust server.

cd rust-server && cargo build --release

Publish the current binary into the local development runtime path.

# Windows
pwsh -File scripts/publish-dev-runtime.ps1

# macOS / Linux
./scripts/publish-dev-runtime.sh

In Unity, open Window > Patina Unity MCP, enable Use Local Runtime (Contributor), and click One-Click Setup.

This writes host configs against the local dev runtime instead of the managed packaged runtime. Re-run One-Click Setup after every new cargo build --release + publish-dev-runtime pass, and use Remove Patina From Hosts before switching back to the packaged flow.

Stage a local UPM test package

Use this when you want to test the package as it will be published, not the raw source checkout:

pwsh -File scripts/stage-local-upm.ps1

Then add the staged package from disk in Unity:

dist/local-upm/com.taygunsavas.patina-unity-mcp/package.json

Prefer the staged local package when you are validating package layout, import behavior, or release packaging. Prefer the source checkout path when you are actively editing source and want the fastest edit-build-run loop.

See CONTRIBUTING.md for the full contributor workflow.

Community and Contributing

Start with CONTRIBUTING.md for the local development loop, validation expectations, and pull request guidance.
Use GitHub issue forms for reproducible bugs, feature proposals, and usage questions so maintainers get the context they need.
Read .github/SUPPORT.md before opening a help request.
Read .github/SECURITY.md for private vulnerability reporting.
Read .github/CODE_OF_CONDUCT.md before participating in issues and pull requests.
Pull requests targeting main are expected to pass CI and go through CODEOWNERS + Copilot review once repository rules are enabled.

Requirements

Unity 6 (6000.3 LTS+)
A supported MCP host
Rust 1.75+ (contributors only)

License

MIT

Available Tools

4 tools

patina_callA

Execute an internal Patina Unity command. Targets the agent working-directory workspace by default; pass workspace to target a different project, or sessionId (from patina_sessions) to target one editor directly.

ParametersJSON Schema

Name	Required	Description
`command`	Yes	Internal Patina command name returned by patina_capabilities.
`sessionId`	No	Optional exact Unity session ID from patina_sessions. Sufficient on its own -- the default workspace is not applied as a constraint. Required when one workspace has multiple open editors.
`workspace`	No	Canonical absolute path to the Unity project root. Omit to fall back to this MCP process working directory, which applies only when sessionId is also omitted; supplied together with sessionId, both must resolve to the same session.
`parameters`	No	JSON parameters for the command. Pass {} (or omit) for commands with no parameters. A JSON-object-encoded string (e.g. "{\"x\":1}") is also accepted and parsed; null or an empty/whitespace string is treated as {}. Any other type (number, bool, array, non-object string) is rejected.

TDQS

A3.7/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses the targeting precedence (default working-directory workspace, overridden by workspace or sessionId, with the constraint about both resolving to same session if provided together). However, it gives no information about side effects, permissions, rate limits, or error behavior of executing commands. With no annotations provided, the description carries the full burden but does not address these important behavioral aspects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the core purpose, and includes only essential targeting details. No redundant or fluff content. Each sentence contributes meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's generic nature (executes arbitrary commands) and the absence of an output schema, the description is somewhat under-specified regarding return values and command-specific behavior. It relies on the schema to mention patina_capabilities for command names, but does not explain how outputs are returned or what errors might look like. The targeting info is complete, but broader operational context is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds context to workspace and sessionId parameters by explaining their targeting roles, but the schema already provides detailed descriptions for all four parameters (100% coverage). The reference to patina_sessions in the description is helpful but marginal. Baseline 3 is appropriate since the schema carries the main semantic load.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool executes an internal Patina Unity command, which distinguishes it from sibling tools like patina_capabilities (listing commands) and patina_sessions (listing sessions). It also specifies targeting scope (default workspace, alternative workspace, or sessionId). The verb 'Execute' and resource 'Patina Unity command' make the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context on when to use the default workspace versus specifying a different project via workspace or targeting a specific editor via sessionId. It references patina_sessions as the source for session IDs, which orients the agent to the sibling tool. However, it does not explicitly mention patina_capabilities for command discovery, though that is stated in the schema.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

patina_capabilitiesA

Browse Patina's Unity command catalog without loading every command schema. Filter by category/search/command; set include_schema=true only for commands you intend to call.

ParametersJSON Schema

Name	Required	Description
`search`	No	Optional text search over command names, categories, and descriptions.
`command`	No	Optional exact command name. Use with include_schema=true before calling patina_call.
`category`	No	Optional exact category filter, e.g. "prefab", "asset", "scene", "script", or "validation".
`include_schema`	No	Include JSON parameter schema for returned commands. Defaults to false to keep context small.

TDQS

A4.1/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description must carry the full burden of behavioral disclosure. It states that the tool avoids loading every schema (implying lightweight read operation), but omits other behavioral traits such as auth requirements, rate limits, pagination, or response format. This is adequate but not thorough.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences long, front-loaded with the primary purpose, and every word serves a clear function. There is no redundancy or extraneous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that there is no output schema and no annotations, the description leaves some gaps: the expected return format (list of commands? with which fields?) is not mentioned, nor is there any indication of pagination or ordering. The description is functional for basic use but could be more complete to fully inform the agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, but the description adds value beyond the schema by explaining when to use include_schema (only for intended calls) and its default behavior (false to keep context small). The other parameters are simply listed without additional context, but the general advice on usage is helpful.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool as a command catalog browser with filtering capabilities, and distinguishes it from sibling tools (patina_call, patina_health) by focusing on discovery without loading schemas. The verb 'Browse' combined with the resource 'command catalog' makes the purpose specific and actionable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use the tool (browsing the catalog) and when to set include_schema=true (only for commands to be called). It implicitly distinguishes from patina_call, but could be more explicit about when to skip this tool and directly use patina_call.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

patina_healthA

Return Patina server version, compact MCP surface status, bridge port, command count, and a broker summary (agentClientCount, unitySessionCount counting both connected and reloading sessions, reloadingSessionCount, and per-session detail). Pass include_unity_state=true to prove the routed Unity session is actually responding, not just registered.

ParametersJSON Schema

Name	Required	Description	Default
`include_unity_state`	No	When true, also calls Unity get_editor_state through the bridge.
`include_bridge_diagnostics`	No	When true, calls Unity's bridge-level ping without touching Unity main-thread APIs.

TDQS

A4.1/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does disclose useful behavioral traits: 'unitySessionCount counting both connected and reloading sessions' clarifies a counting nuance, and the include_unity_state semantics explains what that parameter actually verifies. It does not mention permissions or side effects, but this is a read-only health check and the provided detail is substantive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense and front-loaded with the action verb 'Return'. It lists multiple return elements without excessive padding. It is a bit long, but every clause contributes specific information, maintaining good conciseness despite the technical list.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has no output schema, so the description must explain return values, which it does by listing categories and exact field names. It also gives a practical usage scenario for a key parameter. It omits detailed description of include_bridge_diagnostics, but the schema covers it, and the overall picture is sufficiently complete for a health-monitoring tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already documents both parameters (100% coverage), so the baseline is 3. The description adds meaningful extra semantics for include_unity_state by explaining it proves the Unity session 'is actually responding, not just registered.' It does not add detail for include_bridge_diagnostics, but the schema covers its behavior.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with 'Return' and enumerates specific resource outputs (server version, MCP surface status, bridge port, command count, broker summary), making the tool's purpose clear. It is distinct from sibling tools like patina_capabilities or patina_sessions by focusing on health/status metrics.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides a conditional usage hint for include_unity_state=true ('to prove the routed Unity session is actually responding'), which gives some context. However, it does not explicitly state when to use this tool versus alternatives or mention any exclusions or non-use cases.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

patina_sessionsA

List active Unity sessions registered with the shared Patina broker, including workspace paths, health, state (connected|reloading|stale), and reloadCount. Check state="reloading" before assuming a failed call means Unity disconnected -- it may just be recompiling.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It discloses output fields and a valuable behavioral nuance (reloading state can explain failed calls). It does not explicitly state read-only or auth requirements, but for a list operation the key behaviors are covered.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, directly front-loaded with the purpose, and includes only high-value details like the state values and the reloading caveat. No filler or unnecessary repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter listing tool, the description fully covers what the tool does, what fields are returned, and a useful operational tip. No output schema exists, but the description compensates by enumerating the response contents. No gaps are apparent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters, and the schema is empty with 100% code coverage. The baseline for no parameters is 4, and the description adds meaningful context about the data returned, which is more than sufficient.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('List') and identifies the exact resource ('active Unity sessions registered with the shared Patina broker') and the key fields returned. This clearly distinguishes it from sibling tools like patina_health (health check) and patina_call (invoking actions).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides clear context on when to consult this tool, especially the guidance to check state="reloading" before assuming Unity disconnected. While it does not explicitly name alternative tools, the context is sufficient for an agent to decide when this listing is relevant.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

3 tool updatesv1.1.15Aug 14, 2026

Addedpatina_call

Changedpatina_health1 field changed

addedInput schema / properties / include_bridge_diagnostics

Added value: +{
+  "description": "When true, calls Unity's bridge-level ping without touching Unity main-thread APIs.",
+  "type": [
+    "boolean",
+    "null"
+  ]
+}

Addedpatina_sessions

1 tool updatev1.1.7Jul 17, 2026
- Removedpatina_call
3 tool updatesv1.1.6Jul 16, 2026
- First observedpatina_call
- First observedpatina_capabilities
- First observedpatina_health

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.2/5.0

Scored 2026-08-14 08:15 across 4 tools

Disambiguation5/5

Each tool addresses a clearly distinct concern: command discovery, health status, session listing, and command execution. There is no overlap in purpose, and the descriptions reinforce their unique roles.

Naming Consistency4/5

All tools share a consistent 'patina_' prefix with simple, readable names. 'call' is slightly verb-like compared to the noun-style others, but the overall pattern remains obvious and predictable.

Tool Count5/5

Four tools is well-scoped for a bridge server that provides capability discovery, health checks, session monitoring, and command execution. Each tool earns its place without unnecessary bloat.

Completeness5/5

The toolset covers the complete workflow for this domain: discover available commands, check server health, list Unity sessions, and execute commands. No significant gaps are apparent for the stated purpose.

Maintenance

ActivityActive

ResponsivenessSlow

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

ChiR24-unreal_mcp_serverOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
Developer Tools App Automation Software Architecture
2859
Flato Design MCPOAuth
io.github.sologovision
Connect AI agents to Flato's editable canvas runtime through a hosted MCP server.
Design Tools Developer Tools
22
Gessa: game asset generation for AI agentsOAuth
ai.gessa
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
AI & Machine Learning Image & Video Processing Audio Processing
1
mcp-serverOAuth
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2

Related MCP Servers

Unity API Communicator MCP
Developer Tools Games & Gamification
SamDreamsMaker
A
license
B
quality
D
maintenance
Control Unity Editor from AI agents. 200+ MCP tools for GameObjects, Scenes, Assets, Materials, Prefabs, Terrain, Physics, Lighting, and more. Works with Claude, Cursor, Windsurf, VS Code Copilot — any MCP client. Zero config: just npx and go.
Updated 6 months ago (2026-02-25 23:02 UTC)
62
13
MIT
Unity-MCP-Vibe
Developer Tools Code Execution Coding Agents
jlceaser
F
license
Not graded
quality
D
maintenance
A native C# MCP server that gives AI agents real-time control and visual analysis of the Unity Editor, enabling dynamic code execution, scene manipulation, and debugging without external dependencies.
Updated 8 months ago (2025-12-29 13:45 UTC)
6
-
glade-mcpofficial
Developer Tools AI & Machine Learning
Glade-tool
A
license
Not graded
quality
A
maintenance
Connect any MCP-compatible AI client (Claude Code, Cursor, Windsurf) to Unity or Godot. 300+ granular tools, an editor aware system prompt, game design document project context, script semantic search, and skill calibration.
Updated 7 days ago (2026-09-02 19:58 UTC)
205
MIT
ach-mcp
achieveonepark
F
license
Not graded
quality
C
maintenance
An in-editor MCP server that exposes Unity convenience tools to AI assistants, allowing them to read console logs, execute menu items, dump scene hierarchies, and take screenshots.
Updated 2 months ago (2026-07-22 05:13 UTC)
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/taygunsavas/patina-unity-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Patina

Why Patina?

How It Works

Quick Start

1. Install the Unity package

2. Run One-Click Setup

3. Start building

Available Capabilities

Scene

GameObjects

Components & Properties

Batch Operations

Prefabs

Assets

Materials

Scripts

Scriptable Objects

Validation & Health

Search & Query

Console

Editor State & Control

Undo

Build & Player Settings

Test Runner

Animation

Supported Hosts

Troubleshooting

Prefab Stage Save Dialogs

Roadmap

Local Development

Contributor source checkout

Stage a local UPM test package

Community and Contributing

Requirements

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

glade-mcpofficial

Latest Blog Posts

MCP directory API