Provides an efficient MCP facade over the MCP for Unity backend, allowing AI agents to search and call Unity Editor operations, batch sequences of operations, inspect project/editor/scene/console/selected-object state, retrieve stored results, and capture Scene or Game view images.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Unity MCP Efficient Search the catalog for duplicating selected objects in Unity and execute it"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A small compatibility layer that lets AI clients use MCP for Unity without loading its full tool surface into every prompt.
The model sees six stable tools and discovers the required Unity operation on demand. The facade then compacts routine output, preserves full results for bounded retrieval, and batches related work without forcing every intermediate response into the conversation.
Measured against MCP for Unity v10.1.0, the model-visible schema fell from 23,280 estimated tokens to 915, while 377 indexed Unity operations remained reachable. The reproducible benchmark measures context footprint, not API billing.
This project does not replace the Unity package or its Python server. MCP for Unity remains the backend. Register the facade, not the upstream server, with the AI client. Exposing both tool surfaces removes most of the context savings.
On 2026-08-24, the scripts in benchmarks/ produced these results against MCP for Unity v10.1.0 (c14de1e6).
Measurement | Upstream surface | Efficient facade | Reduction |
Model-visible tools | 48 | 6 | 87.50% |
Serialized tool schemas | 93,119 chars | 3,657 chars | 96.07% |
Approximate schema tokens¹ | 23,280 | 915 | 96.07% |
Synthetic 250-object hierarchy² | 628,110 chars | 875 chars | 99.86% |
Approximate hierarchy tokens¹ | 157,028 | 219 | 99.86% |
Action argument surface | 5,566 fields | 1,798 fields | 67.70% |
The dynamic catalog indexed 377 Unity operations. A small deterministic English/Russian search suite returned the expected operation at rank 1 for all 15 cases and within the top 3 for all 15 cases. The release candidate passes 35 facade tests. A live smoke test made no project changes and verified the six-tool surface, editor.refresh at rank 1, editor state, and a two-step scene inspection batch against an open Unity Editor.
¹ Token counts use a transparent four-characters-per-token estimate. They describe context footprint, not API billing. Actual tokenization varies by model and payload.
² The hierarchy benchmark models a noisy response containing 250 objects, 300 vertex indices per object, and the same data in text and structured payloads. This stress case does not promise the same reduction for every scene. See BENCHMARKS.md for the method and raw values.
Related MCP server: Agent Bridge for Unity
Tool | Purpose |
| Finds the best Unity operations from a short English or Russian task phrase. Full schemas are optional. |
| Executes one exact operation and returns a bounded preview plus a recoverable result handle. |
| Runs up to 50 bounded call, select, assert, poll, foreach, and emit steps in one model round trip. |
| Reads project, editor, scene, console, or selected-object state with revision-aware suppression. |
| Pages, filters, searches, or selects data already produced without repeating Unity work. |
| Returns one bounded Scene or Game view image without duplicating it in structured JSON. |
The model still reaches the 377 indexed operations behind the facade. Those operations no longer occupy the prompt all at once.
Common failure mode | What the facade changes |
The client sends dozens of large tool schemas before useful work begins | A six-tool surface with on-demand operation discovery |
Manager tools expose one large union of arguments for every action | Action-specific schemas; 67.70% fewer argument fields in the measured catalog |
Scene, console, test, and asset responses flood the conversation | Unity-aware post-processing, strict output budgets, pagination, and result handles |
A FastMCP or Pydantic | Recursive JSON normalization before preview construction |
Unity completes a mutation but disconnects during domain reload | Raw result persistence, explicit retry metadata, and no automatic mutation replay |
A test run starts but its large envelope hides or loses | A compact asynchronous receipt designed for polling |
The upstream response nests | Outer |
Repeating a timed-out mutation may duplicate work | Stable |
Multi-object work burns one model turn per operation | Bounded sequential workflows and conservative parallel batches for reads |
| Delayed, revision-aware checks with a clear stopping rule |
Codex or another MCP client
|
| sees 6 tools
v
Unity MCP Efficient (stdio by default)
|-- capability search over the live upstream catalog
|-- compact Unity-specific post-processing
|-- bounded workflow runtime
|-- local SQLite result and request receipts
|
| HTTP, default http://127.0.0.1:8080/mcp
v
MCP for Unity server
|
v
Unity Editor packageA skill alone cannot hide tool schemas that an MCP client has already loaded. That is why this repository contains both pieces:
the facade enforces the smaller API and compact responses;
the skill teaches Codex how to search, batch, recover, and verify efficiently.
Install CoplayDev/MCP for Unity using its upstream instructions. In Unity, open Window → MCP for Unity, select the local HTTP transport, and start the server.
The upstream default endpoint is:
http://127.0.0.1:8080/mcpIf your project uses another port, pass it through UNITY_MCP_BACKEND_URL below.
Install uv when needed, then run:
codex mcp add unity-efficient \
--env UNITY_MCP_BACKEND_URL=http://127.0.0.1:8080/mcp \
-- uvx --from git+https://github.com/Vangardo/unity-mcp-efficient.git@v0.2.0 unity-mcp-efficientOn PowerShell, use the same command on one line:
codex mcp add unity-efficient --env UNITY_MCP_BACKEND_URL=http://127.0.0.1:8080/mcp -- uvx --from git+https://github.com/Vangardo/unity-mcp-efficient.git@v0.2.0 unity-mcp-efficientRemove or disable any direct MCP for Unity entry from the same Codex client. Keep the upstream HTTP server running, but do not register its 48-tool surface with the model.
The easiest route is to ask Codex:
$skill-installer Install the skill from https://github.com/Vangardo/unity-mcp-efficient/tree/v0.2.0/skills/unity-mcp-efficientFor a manual user-level install, clone the repository and copy skills/unity-mcp-efficient to:
$HOME/.agents/skills/unity-mcp-efficientCodex detects skill changes automatically. Restart it if the skill does not appear.
Use this stdio configuration shape:
{
"mcpServers": {
"unity-efficient": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/Vangardo/unity-mcp-efficient.git@v0.2.0",
"unity-mcp-efficient"
],
"env": {
"UNITY_MCP_BACKEND_URL": "http://127.0.0.1:8080/mcp"
}
}
}
}Install the packaged skill when the client supports the Agent Skills format. The facade works without it, but the skill improves tool selection and recovery behavior.
Inspect low-detail Unity state once.
Search with one concrete task phrase.
Request the selected schema when its arguments are unclear.
Batch known dependent work sequentially. Parallelize independent reads, never Unity mutations.
Keep compact output and expand stored results by path or page.
Verify the semantic result, not every raw intermediate object.
This loop is already encoded in skills/unity-mcp-efficient/SKILL.md.
Variable | Default | Meaning |
|
| Upstream MCP for Unity HTTP endpoint |
|
| Per-operation timeout in seconds |
| OS user cache directory | SQLite result store path; use |
|
| Facade transport: |
Keep the default stdio transport unless you have a reason to expose the facade over a network. Read SECURITY.md before using HTTP or SSE.
git clone https://github.com/Vangardo/unity-mcp-efficient.git
cd unity-mcp-efficient
uv sync --extra dev
uv run pytest -qWith the upstream HTTP server running:
uv run python benchmarks/evaluate_facade.py
uv run python benchmarks/measure_surface.py
uv run python benchmarks/live_smoke.pyevaluate_facade.py and measure_surface.py read the live upstream catalog. live_smoke.py makes no mutations, but it requires an open and connected Unity Editor.
Compact output is intentionally lossy. The untouched raw result remains available through get_result for a bounded time.
The facade does not make arbitrary Unity mutations safe. Permissions and review still belong to the MCP client and user.
Parallel mode is conservative. Unity may serialize editor work internally.
A discoverable optional capability, such as Roslyn support, may still be absent from a particular Unity project.
Scene and Game view capture may omit IMGUI or editor overlays.
Compatibility tests use MCP for Unity v10.1.0. The catalog is dynamic; benchmark later upstream releases before claiming support.
We took the progressive-disclosure idea from work on Vangardo/mcp_hub, a broader MCP gateway that routes a large integration catalog through a small search-and-call surface. Unity MCP Efficient applies that context discipline to Unity, then adds Unity-specific compaction, revision checks, mutation recovery, screenshots, and bounded local workflows.
If you need this pattern for Slack, Teamwork, Telegram, calendar, memory, automation, or cross-service agents, see MCP Hub.
The Unity compatibility backend is CoplayDev/MCP for Unity, distributed under the MIT License. This repository is an independent project and does not include its source code. See NOTICE.md and THIRD_PARTY_NOTICES.md.
The original code in this repository is available under the MIT License.
Unity is a trademark or registered trademark of Unity Technologies or its affiliates in the United States and elsewhere. This project is not affiliated with or endorsed by Unity Technologies or CoplayDev. Other names and brands belong to their respective owners.
Run calls or local select/assert/poll/foreach/emit workflow steps.
| Name | Required | Description | Default |
|---|---|---|---|
| execution | No | sequential | |
| max_chars | No | ||
| operations | Yes | ||
| request_id | No | ||
| output_mode | No | compact | |
| response_mode | No | summary | |
| stop_on_error | No | ||
| unity_instance | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the safety profile (destructiveHint=true, readOnlyHint=false, idempotentHint=false), which the description does not contradict. The description adds only the 'local' qualifier for workflow steps and the step-type list; it does not disclose error behavior, execution-mode effects, or what summary/steps/emits responses contain, so added value beyond annotations is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Twelve words in a single sentence, verb-front-loaded, with no filler or redundant content. Every word earns its place by naming either the action or the specific step types.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a complex tool — eight parameters, a required nested operations array with no item schema (additionalProperties only), three enum parameters, a destructive annotation, and no output schema. The description does not explain how to structure an operation item, what the response looks like, or how the response_mode/output_mode options differ, leaving an agent without enough information to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate, and it does clarify the key required parameter: operations can be either calls or local select/assert/poll/foreach/emit steps. But the other seven parameters (execution, max_chars, output_mode, response_mode, stop_on_error, request_id, unity_instance) receive no semantic explanation anywhere, so the compensation is only partial.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific action ('Run') and a concrete resource ('calls or local select/assert/poll/foreach/emit workflow steps'), so an agent can tell that this tool executes operations rather than inspecting state. However, it does not explicitly contrast with the sibling call_operation, leaving the batch-vs-single distinction to be inferred from the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to choose batch_operations over call_operation, get_result, or the other siblings. There are no use cases, prerequisites, or exclusions stated; an agent must infer from the name alone that this is for running multiple operations at once.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute once; request_id safely deduplicates retries of mutations.
| Name | Required | Description | Default |
|---|---|---|---|
| arguments | No | ||
| max_chars | No | ||
| operation | Yes | ||
| request_id | No | ||
| output_mode | No | compact | |
| unity_instance | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark destructiveHint=true and idempotentHint=false; the description adds useful behavioral context by stating execution is once-only and that request_id deduplicates retries. It does not disclose failure modes, side effects beyond mutation, or result-handling behavior, but it goes beyond what the annotations already convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence with no filler, and it front-loads the key execution behavior. It is admirably concise for a tool with six parameters, though arguably too terse to fully educate an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the destructive hint, six parameters, no output schema, and zero schema coverage, one line is not enough context. The request_id guidance is valuable, but the agent is left without sufficient details on how to specify the operation, shape arguments, choose output_mode, or interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for six parameters, but it only explains request_id. Critical parameters such as operation, arguments, output_mode, max_chars, and unity_instance are left wholly undocumented, making correct invocation harder than it should be.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the tool as a single-execution operation invoker ('Execute once') and references mutations, which helps distinguish it from sibling tools like batch_operations. However, it never explains what an 'operation' actually is or what domain it operates on, so some clarity is left to inference from the tool name and parameters.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for single mutations and mentions safe deduplication of retries, but it gives no explicit when-to-use guidance or when-not-to-use alternatives. It does not tell the agent to prefer read-oriented siblings for inspection or batch_operations for multi-step work.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Page, select, or search a prior result without repeating Unity work.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | ||
| limit | No | ||
| offset | No | ||
| pattern | No | ||
| max_chars | No | ||
| result_id | Yes | ||
| output_mode | No | standard |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context by indicating that the tool works over prior results and avoids re-running Unity work, but it does not reveal details about output modes, pagination behavior, or any hidden side effects. This is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler, and the key behavioral point about not repeating Unity work is front-loaded. It earns its place, though the brevity contributes to the lack of parameter clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With seven parameters, no parameter descriptions, no output schema, and an already-terse tool description, an agent has insufficient context to call the tool confidently. The description does not explain how paging, search, output modes, or character limits behave, leaving important invocation details to inference.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the seven parameters, but it does not. 'Page, select, or search' loosely maps to limit/offset, result_id, and pattern/path, yet parameters such as max_chars, output_mode, and path remain unexplained. The description provides only weak semantic hints and does not carry the parameter-documentation burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies a specific resource ('a prior result') and a set of verbs ('Page, select, or search'), which makes the tool's purpose reasonably clear. It also adds the motivational context of avoiding repeated Unity work, but it does not explicitly differentiate itself from sibling tools like search_capabilities or call_operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'without repeating Unity work' implies this tool should be used when a previous result already exists and should be retrieved rather than recomputed. However, there is no explicit guidance on when to prefer get_result over siblings such as call_operation or search_capabilities, and no exclusions or alternative conditions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return one bounded inline viewport image for visual verification.
| Name | Required | Description | Default |
|---|---|---|---|
| source | No | scene_view | |
| target | No | ||
| max_resolution | No | ||
| unity_instance | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish that the tool is read-only, idempotent, and non-destructive, so the description need not repeat that. It adds a small behavioral detail—the result is a single inline bounded image—but leaves the semantics of 'bounded' and the meaning of source/target selection unexplained. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence, front-loaded with the action and resource, with no filler. It is concise and readable, though it could afford a second sentence to explain key parameters or use cases without becoming bloated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with four parameters, no output schema, and no parameter descriptions, this description is incomplete. An agent cannot infer what 'target' means, how max_resolution behaves, or how to select scene_view versus game_view, and there is no guidance on how to interpret the returned image.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description names none of the four parameters (source, target, max_resolution, unity_instance). The enum for source and default values in the schema provide some hints, but the description adds no parameter-level meaning and fails to compensate for the zero coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Return') with a clear resource ('one bounded inline viewport image') and states the purpose ('for visual verification'). It is distinguishable from generic sibling names like get_result or inspect_unity, though it does not explicitly contrast with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'for visual verification' implies this tool is for obtaining an image to verify a scene or game view, but the description does not state when to use it instead of alternatives like inspect_unity or get_result, nor are exclusions given. Usage context is inferred rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Inspect Unity semantically; unchanged revisions return no repeated payload.
| Name | Required | Description | Default |
|---|---|---|---|
| scope | No | state | |
| detail | No | standard | |
| targets | No | ||
| max_chars | No | ||
| since_revision | No | ||
| unity_instance | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, and the description adds the concrete behavior that unchanged revisions produce no repeated payload, which clarifies what idempotency means here. It also lets the agent infer that since_revision is tied to change detection. No statement contradicts the read-only/idempotent annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and the behavioral note does earn its place, but 'semantically' is cryptic and the text is under-specified for a tool with six parameters. It is concise in word count, yet not 'appropriately sized' for the complexity the schema reveals.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With low schema coverage, no output schema, and six parameters, the description leaves important context missing: what a successful inspection returns, which scopes are involved, what targets selects, and how unity_instance affects execution. The single revision-related sentence is useful but far from complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description bears the burden, but it only loosely clarifies since_revision via 'unchanged revisions'. The other five parameters—scope, detail, targets, max_chars, unity_instance—are left entirely to name/enum inference, and targets in particular is ambiguous.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a verb and resource ('Inspect Unity') but 'semantically' is undefined, and nothing in the text distinguishes it from siblings like get_viewport or search_capabilities. The second clause describes revision behavior rather than clarifying what inspection covers. It is not a complete tautology, but the core phrasing largely restates the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given for when to use inspect_unity instead of sibling tools such as get_viewport, call_operation, or search_capabilities. There are no exclusions, prerequisites, or context triggers. An agent must infer usage from the schema alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find operation names and only the argument hints needed next.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | No | ||
| refresh | No | ||
| category | No | ||
| include_schema | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark it read-only, idempotent, and non-destructive; the description adds a scoping claim: results contain operation names and only the argument hints needed next. This is useful but vague, and it does not disclose output shape, refresh behavior, or query semantics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The definition is one short sentence and front-loads the main action, but it is under-specified rather than economically complete; important behavioral and parameter information is missing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With five optional parameters, no output schema, and no parameter descriptions, the description must carry more weight. It gives the broad purpose but omits the query semantics, return shape, and how the result connects to call_operation, so the tool is not sufficiently contextualized.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across five parameters (limit, query, refresh, category, include_schema), yet the description names none of them and only references 'argument hints' as output. This is a serious gap: an agent cannot know what query string, limit, or include_schema controls.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Find operation names') and the scope of results ('argument hints needed next'), which distinguishes it from sibling tools that call/get/batch operations. However, it does not explicitly differentiate from 'inspect_unity' or clarify what 'capabilities' means in context, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'needed next' implies this is a discovery step before invoking an operation, giving some context. But it offers no explicit guidance on when to choose this over call_operation, get_result, inspect_unity, or batch_operations, and no exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.2.0batch_operationscall_operationget_resultget_viewportinspect_unitysearch_capabilitiesEach tool targets a distinct phase of interaction: discovery, execution, result retrieval, batching, semantic inspection, and visual verification. There is no meaningful overlap that would cause an agent to misselect between them.
All tool names follow a consistent verb_noun snake_case pattern: search_, call_, get_, batch_, inspect_, get_. This makes the set predictable and easy to navigate.
Six tools is a well-scoped count for an efficiency-focused server. Each tool earns its place and the set avoids both bloat and thinness.
The surface covers the main lifecycle well: discover capabilities, execute operations, retrieve results, batch workflows, inspect Unity state, and verify visually. Minor gaps exist, such as no explicit cancellation or full listing tool, but search_capabilities and batch_operations cover most practical needs.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
The OpenRouter for tools. One MCP connection gives any AI agent 254 hosted tools, pay per call.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
Unified MCP Server is a remote MCP connector for AI agents and vertical AI products that provides access to 22,000+ authorized SaaS tools across 400+ integrations and 24 categories directly inside LLMs (Claude, GPT, Gemini, Cohere). Tools operate only on explicitly authorized customer connections, enabling agents to safely read and write against live third-party systems.
Multiple MCP tools, persistent graph memory, token-saving data pointers, and more.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Vangardo/unity-mcp-efficient'
If you have feedback or need assistance with the MCP directory API, please join our Discord server