io.github.sterion66/godot

by sterion66

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.3
Disambiguation2/5
Many tools overlap in purpose, especially the retrieval/listing family: godot_get_project_files, godot_watch_files, godot_find_by_pattern, godot_find_assets, and the list_scenes/list_scripts/list_resources trio all inventory project files in similar ways. godot_create_code_template vs godot_create_script and godot_edit_file vs godot_write_file also have unclear boundaries, making tool selection ambiguous.
Naming Consistency5/5
All tool names follow the same godot_verb_noun pattern with snake_case throughout, making the naming convention highly predictable. Minor semantic issues like godot_watch_files not actually watching files do not break the syntactic consistency.
Tool Count2/5
40 tools is well beyond the 25-tool threshold for a cohesive set, and the high count is driven partly by redundant file-discovery operations. While Godot integration is a broad domain, this surface feels heavier than necessary and could be consolidated.
Completeness3/5
The server covers creation, reading, editing, validation, running, asset downloads, and plugin/autoload inspection, so core Godot workflows are mostly represented. However, there are no delete, rename, export, or project-settings update tools, and the read-only project settings plus overlapping file operations leave notable lifecycle gaps.
Average 3.5/5 across 40 of 40 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- Last stable release on April 16, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint=true annotation already establishes that this is a safe read operation, and the description ('Get information') is consistent with that, so there is no contradiction. However, the description adds no behavioral context beyond the annotation — it does not disclose error behavior for missing files, whether project_path discovery from cwd has any side effects, or what operationally happens when the call executes.
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?
One short, grammatically complete sentence with zero wasted words and the key action front-loaded. The terseness is a content-completeness issue, not a conciseness defect — for a simple 2-parameter tool this is appropriately sized.
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?
The presence of an output schema covers return-value documentation, and annotations cover the safety profile, so the structured data carries much of the burden. However, the description provides almost no situational context: it cannot help an agent distinguish this file-info tool from node/asset/project info siblings, and it leaves the meaning of 'information' undefined. Given the low complexity and rich accompanying schema, a minimal description is viable, but this one sits at the edge of adequacy.
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?
Schema description coverage is 100%: file_path is documented as 'Path to the file' and project_path as 'Optional project root (defaults to discovery from cwd)'. Since the schema fully documents both parameters, the baseline of 3 applies. The description adds nothing beyond the schema — it merely restates the file concept already covered by file_path.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and identifies the resource ('a file'), so the core purpose is understandable. However, 'information about a file' is generic and provides no specifics about what kind of information is returned. Among siblings like godot_get_node_info, godot_get_project_info, and godot_get_asset_info, the description does not differentiate this tool from its peers — the name itself carries most of the disambiguating weight.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. With roughly 35 siblings including several other 'get_*_info' tools, the description gives no conditions, exclusions, or hints about which tool fits which scenario. An agent must infer usage entirely from the parameter schema and name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide only a title, so the description carries the full behavioral burden. It says 'Run' but does not disclose whether the process blocks, whether it opens a window, what side effects occur, or how headless mode and auto-quit affect execution.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence and therefore concise, but it is also under-specified and mostly restates the title. Given the tool has four parameters and meaningful behavioral choices, the description is not appropriately sized for the task.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description omits essential behavioral context such as blocking behavior, display behavior, and when to prefer this over sibling tools. Even though an output schema exists and parameters are documented, the overall definition is too thin for an agent to invoke this tool confidently in varied contexts.
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?
Schema description coverage is 100%, with all four parameters documented including defaults and purpose. The description adds no parameter-level meaning, but the baseline of 3 applies because the schema already handles this dimension.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Run' and the resource 'Godot game', so an agent can tell this tool launches a game. It does not differentiate from siblings such as godot_execute_script, but it is not vague enough to be a tautology.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives like godot_execute_script or godot_validate_scene. The description only states the action and provides no context, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide only a title, so the description carries the full burden of behavioral disclosure. It communicates that a file is created (a write operation), but says nothing about whether existing files are overwritten, what side effects occur in the project, or what happens without a project_path. For a mutation tool with no annotation support, this is a significant transparency gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence with no wasted words, and the action is front-loaded. However, it is under-specified for a tool with 5 parameters and potential file-system side effects; the brevity reflects lack of content rather than disciplined editing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need no explanation, and parameter coverage is complete. But the description fails to address key operational context: overwrite behavior, how the scene relates to the Godot project, when create_scene is preferred over create_resource or write_file, and what 'new' means when a target file already exists. A 5-parameter creation tool needs more than this one-liner.
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?
Schema description coverage is 100%, so the schema already documents all five parameters. The description adds no parameter-level meaning beyond what the schema provides, which matches the baseline-3 case where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource — 'Create a new scene file.' — which clearly identifies the operation. It is distinguishable from read/validate/list scene siblings by its creation verb, though it does not actively differentiate itself from other create_* tools like godot_create_resource or godot_create_script beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives such as godot_create_resource, godot_create_script, godot_write_file, or godot_validate_scene. There are no usage conditions, exclusions, or workflow hints, leaving the agent to infer appropriate invocation context on its own.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral detail beyond the annotation-provided readOnlyHint. It does not disclose what validation actually does, whether it reports a list of errors, whether it depends on the Godot binary, or whether project_path affects behavior. With readOnlyHint present the safety profile is clear, but no additional behavioral context is provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence and is front-loaded, but it is under-specified rather than efficiently complete. For a validation tool with multiple sibling tools, a one-line description omits useful context, so this is closer to acceptable brevity than ideal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there is an output schema and readOnly annotation, the description does not need to explain return values or non-modification. However, it still lacks any explanation of what validation entails, when validation is appropriate, or how this differs from the nearly identical godot_validate_script sibling. The context is too thin for an agent to confidently select and invoke the tool correctly.
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 input schema already describes both parameters with 100% coverage, including the default discovery behavior for project_path. The tool description itself adds no parameter-level meaning, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('validate') and a resource ('scene file'), which clearly separates it from sibling tools like read_scene or create_scene. However, it does not explain what validation checks (syntax, references, project settings) or contrast with validate_script, so it stops 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance about when to use this tool versus alternatives. The description does not mention scenarios such as validating before running a game, comparing to godot_validate_script, or any exclusions. The caller must infer the intended use from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide no safety hints, so the description must carry the behavioral burden. It does not state whether existing files are overwritten, whether directories are created, or what side effects writing a file has. This is critical for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence with no wasted words, but it essentially restates the title. While concise, it would be more valuable if it front-loaded key behavioral details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a write operation with no annotations, the description is too under-specified. It does not cover overwrite semantics, path resolution relative to project_path, expected content format, or distinction from edit/create tools. An agent cannot predict side effects from this description alone.
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?
Schema description coverage is 100%, so the schema already documents all three parameters. The description adds no additional parameter meaning, but the baseline of 3 applies because the schema handles the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a clear action and resource: write content to a file. However, it does not differentiate from siblings such as godot_edit_file or godot_create_resource, so it lacks sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. It does not mention that this might create or overwrite files, how it relates to godot_edit_file, or when the optional project_path is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations do not include readOnlyHint or destructiveHint, so the description carries the full burden. It implies creating a file but does not disclose whether it writes to disk, whether it can overwrite existing files, whether a project path is required, or what file extension/format is produced. This is a significant gap for a mutation tool.
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 a single sentence with no filler and leads with the action verb. It is concise but arguably too brief to carry the full contextual load; still, there is no unnecessary wordiness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that creates a resource file within a Godot project, the description omits prerequisites, file location/extension behavior, how project_path is used, and any differentiation from sibling creation tools. The output schema exists but does not compensate for the missing behavioral and usage context.
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?
Schema description coverage is 100%, and the input schema already explains each parameter (resource_type, optional properties, project_path, resource_name). The description adds no parameter-specific meaning, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear action ('Create') on a clear object ('a new resource file'), which distinguishes it at a category level from sibling creation tools like godot_create_script and godot_create_scene. However, it does not explicitly call out what a 'resource file' is or how it differs from those siblings, so it does not fully earn a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance about when to use this tool versus alternatives such as godot_create_script, godot_create_scene, or godot_create_code_template. No prerequisites (e.g., an existing project) or context for when resource creation is appropriate are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations supply only a title, so the description carries the full burden of behavioral disclosure. Saying 'Create a new GDScript file' implies a mutation but does not explain whether existing files are overwritten, where the file is created, whether a project must be open, or what the tool returns.
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 a single sentence with no filler, and the action and resource are front-loaded. It is compact and readable, earning its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with seven parameters and side-effecting file creation behavior, this one-liner is under-specified. It omits expected side effects, overwrite semantics, required setup, and guidance on how parameters like class_name and extends relate to the operation, even though the schema covers individual parameter details.
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?
Schema description coverage is 100%, and the input schema documents each parameter with names, defaults, and formats for exports and signals. The description itself adds no parameter-level meaning, so the baseline score of 3 is appropriate because the schema handles the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Create') and a clear resource ('a new GDScript file'), so the tool's core function is immediately understandable. It is less explicit at distinguishing itself from sibling creation tools like godot_create_resource or godot_create_scene, though the 'GDScript' target narrows the scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives such as godot_create_code_template, godot_write_file, or godot_validate_script. There is no mention of prerequisites, project context, or situations where another tool would be preferable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide only a title, so the description carries the full burden of behavioral disclosure. It does not mention that executing arbitrary GDScript can have side effects on the project, require a Godot binary, or emit output, leaving the behavior unclear.
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 a single concise sentence with no filler. It is front-loaded with the main action, though it could afford to include more context without becoming wordy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The schema and output schema are present, but for an arbitrary code-execution tool with no annotations, the description omits critical context such as side effects, prerequisites, and when to choose it over sibling tools. This makes the definition incomplete for safe and correct invocation.
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?
All three parameters are already documented in the schema with clear descriptions, so the baseline is 3. The description adds no additional meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Execute') and a resource ('GDScript') in a project context, making the core purpose clear. It does not explicitly differentiate from sibling tools like godot_validate_script or godot_run_game, but the verb makes the execution intent unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives such as godot_validate_script, godot_create_script, or godot_run_game. The agent is left to infer selection criteria from the name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide only a title, so the description carries the full behavioral burden. 'Find files matching a pattern' is essentially a restatement of the name; it does not disclose recursion behavior, path scope relative to project_path, handling of hidden files, or explicitly confirm non-destructive behavior except by implication.
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 a single, front-loaded sentence with no filler or unnecessary content. It is easy to scan and appropriately brief, though that brevity contributes to the lack of contextual guidance penalized elsewhere.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Parameter complexity is low and an output schema exists, which reduces the burden, but the description is not complete for an agent choosing among many similar sibling tools. It does not explain the relationship between pattern and project_path, the search scope, or how it differs from related listing/search tools.
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?
Schema coverage is 100%: pattern is documented with a glob example ('**/*.gd') and project_path is described as an optional project root. The description adds no parameter details, but with complete schema descriptions the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear action and object: find files, with a specific criterion, matching a pattern. It is unambiguous about what the tool does, but it does not differentiate it from the many sibling file-listing/search tools, which prevents a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus siblings like godot_get_project_files, godot_search_content, godot_find_unused_files, or the list_*/find_* tools. There are no exclusions, alternatives, or selection cues beyond the bare mechanism.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description merely restates the title and adds no behavioral context beyond what the readOnlyHint annotation already conveys. It does not mention what kind of information is returned, how project_path behaves when null, or how include_assets affects results.
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 a single concise sentence with no filler or irrelevant details. It is front-loaded and easily scannable, though it is so terse that it adds little beyond the tool's title.
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?
For a simple read-only listing tool, the description, schema, annotations, and output schema together are minimally sufficient. However, the lack of usage context and sibling differentiation leaves an agent uncertain about why this tool exists alongside several similar list-oriented tools.
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?
Schema description coverage is 100% for both parameters, so the schema already documents project_path and include_assets. The tool description adds no additional parameter meaning, which keeps this at the baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Get') and resource ('all files in the project'), making the tool's basic purpose understandable. It does not explicitly distinguish itself from sibling list tools such as godot_list_resources or godot_list_scripts, but the broad 'all files' scope is reasonably clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus the many sibling listing tools. There are no alternatives mentioned, no exclusions, and no context for choosing this over godot_list_resources, godot_find_assets, or similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes that this is a safe read operation, and the description does not contradict it. However, the description adds no behavioral context beyond the word 'official' – no pagination behavior, result format, or any side effects are disclosed. With annotations present, the bar is lower, but this description still adds almost no value beyond them.
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 a single sentence with no filler or redundant content, making it highly concise and easy to parse. It is front-loaded and efficient, though it does not make use of the space to add useful guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters and operates in a crowded sibling namespace, the description is too thin to give the agent a complete picture. It does not explain what the Asset Library is, how results behave, or how this search differs from godot_find_assets. The output schema may cover return values, but the high-level context needed for correct tool selection 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?
Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond what the schema already provides, which is acceptable because each parameter already has a meaningful description and default values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Search') and resource ('official Godot Asset Library'), which clearly states what the tool does. However, it does not distinguish this from sibling tools like godot_find_assets or godot_search_content, leaving potential ambiguity about scope (official online registry vs. local project content).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as godot_find_assets or godot_get_asset_info. There are no conditions, exclusions, or references to sibling tools, so an agent must infer context from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations supply only a title, so the description bears the burden of behavioral disclosure. It adds little beyond the title: no scope defaults, regex semantics, read-only guarantee, or behavior around file_types/project_path. 'Search' implies non-mutating behavior but it is not explicit.
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?
One short, front-loaded sentence with no filler. It is appropriately concise for a simple search tool, though the brevity comes at the cost of missing broader context captured in other dimensions.
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?
The presence of an output schema and fully documented parameters fills some gaps, but the description does not address how this tool relates to the many sibling find/search tools or what the default search scope is. An agent could invoke it reasonably but may pick the wrong sibling without further context.
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?
Schema description coverage is 100%, and all three parameters already have descriptions: regex pattern, file_types, and optional project_path. The tool description itself adds no parameter-level meaning, so the schema-carrying baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Uses a specific verb 'Search' and resource 'content in Godot files', making the core operation clear. It is not explicitly differentiated from sibling godot_find_by_pattern, but 'content' helps narrow it versus file listing or file info tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no guidance on when to use this tool versus alternatives such as godot_find_by_pattern, godot_find_unused_files, or godot_get_project_files. No exclusions, prerequisites, or selection criteria are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already declares this as a read-only operation, and 'Check' is consistent with that. However, the description adds no extra behavioral detail beyond the annotation, such as what happens when godot_path is omitted or whether the tool errors on a missing executable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, short sentence without filler, which is structurally clean. However, it essentially restates the title and contributes little additional orienting information, so it is concise but not particularly value-adding.
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 low complexity, full parameter schema coverage, an output schema, and a readOnlyHint annotation, the description is close to sufficient. Still, it omits when-to-use context and does not explain the behavior of the optional path parameter, which are small but real gaps.
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 sole parameter, godot_path, is fully documented in the input schema with the description 'Path to Godot executable' and a default of null, so schema coverage is 100%. The description itself adds no further meaning about how the path is resolved or used.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action ('Check') and the resource ('the Godot version'), so an agent can infer the basic operation. It does not explicitly differentiate from siblings, but 'version check' is distinct enough among the listed tools. Its near-verbatim repetition of the title keeps it from a top score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, and no context about scenarios where version checking is needed. It neither names related tools nor states exclusions, leaving usage entirely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide no read-only or destructive hints, so the description carries the behavioral burden, but it only states 'replacing content.' It does not disclose what happens if old_content is not found or appears multiple times, whether changes are reversible, or if any backup/confirmation mechanism exists.
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 a single short sentence that is front-loaded and contains no filler. Every word contributes to the core 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?
The core operation is clear and the schema covers all parameters, with an output schema present to describe return values. However, for a mutating operation with no annotation support, the description could reasonably include at least a note about replacement behavior or when to prefer this over write_file.
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 input schema already describes all four parameters with 100% coverage, so the baseline is 3. The description's 'replacing content' loosely maps to old_content/new_content but adds no extra constraints, formatting details, or nuances beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Edit') and resource ('Godot file') and clarifies the operation with 'replacing content,' which conveys find-and-replace semantics. It is distinct enough from godot_write_file conceptually, though it does not explicitly name the sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives like godot_write_file or godot_update_drive, and no exclusions or prerequisites are mentioned. The agent must infer the intended use case from the tool name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations provide readOnlyHint=true, and the description's 'Search' wording is consistent with that. However, the description adds no behavioral context beyond the annotation, such as external network dependence, rate limits, or search syntax quirks.
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?
A single sentence with no filler. It is front-loaded with the core action and target, making it easy to parse quickly.
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?
For a simple read-only search tool with fully documented parameters, annotations, and an output schema, the description is adequate. It could be more helpful with usage guidance, but nothing essential for making the call 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?
Schema description coverage is 100%, so the parameters are already documented in the input schema. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Search for Godot-related repositories on GitHub.' It clearly states what the tool does and the GitHub scope distinguishes it from local-file or asset-library siblings, though it does not explicitly name an alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives such as godot_search_assetlib or godot_search_content. The description only states the basic action and leaves the selection decision entirely to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide only the title and no behavioral hints. The description says 'Create code from a template' but does not disclose whether the tool writes a file, returns code in the output, overwrites existing files, or how project_path affects behavior. For a creation tool with no annotation coverage, this leaves important behavioral traits undisclosed.
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 compact, front-loaded with the core action, and uses a clean list for the template types. Every sentence or list item contributes information without fluff.
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?
The tool is simple and has an output schema, so return-value documentation is not required from the description. Still, gaps remain around whether code is written to disk or returned, what happens with project_path, and when to choose this over godot_create_script. It is minimally viable but not fully complete.
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 describes all three parameters at 100% coverage, so the baseline is 3. The description adds real value by enumerating the allowed template_type values and mapping them to concrete script types, which is essential for correctly invoking the tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and resource: 'Create code from a template,' and the template-type list clarifies variants. However, it does not explicitly distinguish itself from sibling tools like godot_create_script or godot_create_resource, so it stops short of full differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The template-type list implies when the tool is appropriate, but the description provides no explicit 'use this when' guidance, no exclusions, and no mention of alternatives. With many sibling creation tools present, an agent still has to infer how this differs from godot_create_script or godot_create_scene.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already communicates that this is a safe read operation, and the description is consistent with it. The phrase 'detailed information' adds little behavioral detail, but the output schema can carry return-value expectations, so this is adequate for a simple read tool.
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 one short sentence with no filler and the main verb appears first. It is concise, though it is somewhat redundant with the title and could have used the space to add distinguishing context.
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?
The tool is simple, the schema fully documents the single parameter, and an output schema exists, so missing return-value details are not a problem. However, without usage context to distinguish it from sibling asset/file tools, the description is only minimally complete.
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?
Schema coverage is 100% and the only parameter, asset_id, already has a meaningful description. The tool description adds no additional syntax or format guidance, so it does not exceed the baseline established by the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb-resource pair ('Get detailed information about an asset') and aligns with the tool name and title. It is unambiguous about the operation, though it does not explicitly differentiate from similar sibling tools such as godot_get_file_info or godot_find_assets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to call this tool instead of the many related asset/file tools. The agent must rely on the tool name and schema, since the description gives no context about prerequisites, selection criteria, or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation covers the safety profile, but the description adds no behavioral context beyond restating that the tool gets information. It does not mention how missing or invalid node types are handled, whether built-in and custom types are supported, or the shape of the returned information.
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 a single sentence with no filler or redundancy. The key resource ('node type') is front-loaded, making the purpose immediately clear.
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?
This is a simple read-only lookup with one well-documented parameter and an output schema present, so the description does not need to explain return values. The main remaining gap is the vagueness of 'information,' but for a basic introspection tool this is largely sufficient.
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 input schema fully documents the single parameter with an example ('Node2D, CharacterBody2D'). The description adds no additional semantic detail beyond what the schema already provides, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb and resource: 'Get information' about a 'Godot node type.' This distinguishes it from sibling tools like godot_get_file_info and godot_get_project_info, though 'information' is somewhat vague about what exactly is returned.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The intended usage must be inferred entirely from the tool name and the one-line description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description is consistent with the readOnlyHint annotation, indicating a read operation with no destructive side effects. However, it adds no behavioral detail beyond what annotations already provide, such as what 'detailed information' includes or how the project is located. Given the annotation coverage, this is acceptable but not enriched.
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 a single, short sentence with no filler or redundant content. It is front-loaded with the main action, though the phrase 'detailed information' is somewhat vague and duplicates the general idea already present in the title.
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?
For a simple read-only tool with one optional parameter and an output schema, the description is minimally adequate. It does not, however, clarify how this tool differs from godot_get_project_settings or what kind of 'detailed information' is returned, leaving some ambiguity for an agent selecting among siblings.
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 input schema covers the single parameter fully with a description: 'Optional path to project.godot file (defaults to finding it)'. The tool description adds no additional parameter semantics beyond the schema, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb and resource: 'Get detailed information about the Godot project.' It is not a tautology and is understandable on its own. However, it does not distinguish itself from the closely named sibling godot_get_project_settings, so it lacks sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives such as godot_get_project_settings or godot_get_file_info. The description only states what it does, with no context about when it is the appropriate choice. The optional project_path parameter could imply usage context, but the description does not explain it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description aligns with the readOnlyHint annotation and adds the notion that the file is parsed rather than just returned raw. However, it does not disclose error behavior, project discovery details, or what happens if the scene path is invalid. Since annotations already establish the safe-read nature, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no wasted words, and the core action is front-loaded. It is concise without sacrificing the essential 'read and parse' semantics.
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?
For a simple read-only tool, the combination of the description, schema, annotations, and output schema is reasonably complete. The main gap is the lack of routing guidance to distinguish it from similar scene/script inspection tools, but that is already scored under usage guidelines.
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 input schema already describes both parameters with 100% coverage, so the description does not need to repeat them. The description adds no parameter-specific meaning, but the schema carries the burden sufficiently.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb ('Read') and resource ('scene file'), and 'parse' hints that the result is structured rather than raw. It is not fully differentiated from sibling tools such as validate_scene or list_scenes, but it does make the core 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 Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives like godot_read_script or godot_list_scenes. There are no when-not-to-use conditions or explicit references to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, so the safe-read nature is covered. The description adds the 'recent' qualifier, which usefully signals that only recent log entries are returned rather than the entire log. It does not disclose details like log location or behavior with null project_path, but that is partially covered by the parameter schema.
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?
One short sentence effectively communicates the core function with no filler. The key resource and scope are front-loaded.
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?
For a simple read-only tool with fully documented optional parameters and an output schema, the description is minimally adequate. However, it omits usage context, alternatives, and the meaning of a null project_path, leaving some burden on the agent.
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?
Schema documentation covers 100% of parameters, so the baseline is 3. The description adds no additional parameter context beyond the schema's explanations of 'lines' and 'project_path'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Get recent Godot log entries.' It clearly identifies the tool's function and the resource type. However, it does not explicitly contrast with any sibling tool, so it stops short of full differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The description simply states what it retrieves, leaving the agent to infer the appropriate context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already conveys the safety profile, so the description isn't required to restate that. The description adds only that it lists autoload singletons, but doesn't mention behavior around the optional project_path parameter, such as what happens when it's null or how the project is located.
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 a single four-word sentence with no filler or redundant content. It is efficiently front-loaded and easy to parse.
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?
For a simple read-only list operation with an output schema, the description plus annotations are nearly complete. The only notable gap is the absence of guidance about how project_path behaves, but this is minor given the schema already marks it as optional.
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?
Schema description coverage is 100% since the only parameter, project_path, has 'Optional project root' in the schema. The tool description adds no additional meaning beyond this, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List autoload singletons' uses a clear verb and resource, and 'autoload singletons' distinguishes this from sibling list tools such as godot_list_scripts and godot_list_resources. However, it relies on Godot-specific terminology and doesn't explicitly state the project scope or what an autoload singleton is.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no indication of when to use this tool versus the many sibling tools (e.g., godot_list_scripts, godot_list_resources). It also doesn't explain whether the optional project_path should be supplied or what the default behavior is when it's omitted.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so no contradiction. The description adds a small behavioral detail (only .tscn files, scoped to the Godot project) beyond the annotations, but it doesn't disclose return format details, recursion behavior, error handling, or whether hidden/generated files are excluded. With annotations covering the safety profile, a 3 is reasonable.
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?
A single, efficient sentence that conveys the core purpose without redundancy. It is front-loaded with the action and resource, and every word earns its place. Slightly more detail about the strict .tscn filtering could be useful, but it is not bloated.
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?
For a simple list tool with an output schema, readOnlyHint=true, and 100% parameter schema coverage, the description is mostly sufficient. However, it doesn't mention whether subdirectories are recursed, whether the output is sorted, or what the output schema actually contains. These are not critical for calling the tool, but an agent would benefit from knowing the exact behavior.
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?
Schema description coverage is 100%, so the schema fully documents both parameters (relative and project_path). The description adds no parameter-specific meaning beyond the schema, but the schema already provides clear defaults and one-line explanations. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('list') and resource ('.tscn scene files in the Godot project'), making the tool's purpose clear. It does not explicitly differentiate from siblings like godot_list_scripts or godot_list_resources, but the file-type mention provides some distinction.
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?
No explicit when-to-use or alternative routing is provided. The description implies the tool is for listing scene files, but it doesn't state when to prefer it over godot_get_project_files, godot_list_resources, or godot_find_by_pattern. The readOnlyHint and sibling names provide some context, but the description itself lacks explicit usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotation readOnlyHint=true already signals no side effects. The description adds the strict-parameter condition: when strict is true, it may invoke Godot --check-only for parser/type diagnostics if the executable is available. This partially discloses behavior, but it does not clarify what happens when strict is false or when the executable is missing, leaving ambiguity about whether any validation actually occurs.
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 a single purposeful sentence that names the tool's action and object. It is front-loaded and compact. It could add a bit more context, but it earns its place without wordiness.
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?
For a read-only validation tool with an output schema, this is adequate but not complete. The description does not explain what the output contains or how validation behaves when external Godot is absent. Given the complexity of the strict flag and project_path auto-discovery, a little more context would improve completeness, but the presence of an output schema and 100% parameter coverage keeps it at a minimum-viable level.
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?
Schema description coverage is 100%, so the baseline is 3. The description itself adds no extra parameter guidance beyond the schema. The strict parameter's conditional behavior is documented in the schema, and the description says nothing more about script_path or project_path, so it neither helps nor hurts.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb and resource: "Validate a GDScript file." This distinguishes it from siblings like godot_validate_scene, which validates a scene, and from read/create/edit tools. It could be more specific about what validation entails, but the verb-resource pairing is clear enough.
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?
The description implies validation is a read-only check, and the parameter 'strict' explains one mode (running Godot --check-only when executable is available). However, it does not explicitly state when to choose this over godot_validate_scene or other sibling tools, nor does it mention that validation may be skipped when the Godot executable is unavailable unless strict is false.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the read-only safety profile is covered. The description adds only the extension-filtering behavior and does not disclose details such as recursion, case sensitivity, or behavior when no assets match. With annotations handling safety, a mid score is appropriate.
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 a single front-loaded sentence with no wasted words. It is appropriately terse for a simple tool, though it leaves a little room for a clause about scope or alternatives.
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 is low-complexity, the schema documents all parameters at 100%, readOnlyHint covers safety, and an output schema exists. The only notable gap is sibling-tool routing, which is already reflected in the usage_guidelines score, so the overall definition is nearly complete.
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?
Schema description coverage is 100%, so extensions, relative, and project_path are already documented. The description adds no parameter-level meaning beyond identifying that filtering is by extension, which is the baseline contribution expected when schemas are complete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb (find), resource (assets), and filter (by extension), so an agent can tell what it does. However, it does not explicitly differentiate it from sibling tools like godot_find_by_pattern or godot_list_resources beyond that filter.
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?
"Find assets by extension" implies the natural use case is locating project assets by file extension, but it gives no guidance about when to prefer this over alternative find/list tools and no exclusion criteria. This is implied usage rather than explicit routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and the description reiterates 'read-only', with no contradiction. The description adds non-obvious behavioral context beyond the annotation: editor_plugins_enabled mirrors res:// paths from the [editor_plugins] section, and MCP cannot write that section because plugin toggling is user-controlled in the editor. This clarifies data provenance and mutation limits for a specific output field.
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?
Two short sentences with the core purpose front-loaded. The second sentence earns its place by explaining a potentially confusing output field (editor_plugins_enabled) and a write-limit caveat. Compact and efficient, with no filler.
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?
For a simple read-only tool with an output schema present and a single optional parameter, the description covers the essential purpose and the one notable behavioral nuance. It does not state the default behavior when project_path is null, but the schema's 'Optional' label plus default:null adequately covers that. Nothing critical 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?
Schema description coverage is 100% — project_path is already documented as 'Optional path to project.godot' with a null default. The description confirms the source file but adds no new parameter-level semantics beyond what the schema provides, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The first sentence states a specific verb ('Get'), a concrete resource ('project settings from project.godot'), and the read-only nature of the operation. It is clear and self-contained. However, it does not explicitly differentiate from plausible siblings like godot_get_project_info or godot_read_script, though naming project.godot as the source file provides meaningful disambiguation.
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?
No explicit when-to-use or when-not-to-use guidance, and no alternative tools are named despite ~40 siblings. The caveat about editor_plugins_enabled does imply a capability boundary — the tool surfaces plugin state but cannot modify it — which hints at when an agent should not expect this tool to change plugin configuration. This is implied usage context rather than explicit routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no behavioral annotations beyond the title, so the description carries the full burden. It merely says 'refresh project cache,' which is vague about side effects, whether it writes to disk, whether it requires an open project, or whether it is safe/idempotent. This is a significant transparency gap.
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 one short, front-loaded sentence with no filler or repetition. Every word earns its place, and the key trigger condition is included immediately after the main action.
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?
The tool is simple with a single optional parameter and an output schema, so the interface is mostly self-contained. However, the effects of 'refreshing' are unexplained, and without annotations the agent gets no safety or side-effect context. It is minimally viable but leaves behavior to inference.
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?
Schema description coverage is 100%, with project_path described as 'Path to project' and defaulting to null. The tool description adds no extra parameter-level meaning, but the schema already sufficiently documents the only parameter, so the baseline score of 3 is appropriate.
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 states a specific verb ('refresh') and resource ('project cache'), and adds a clear trigger condition ('after file changes'). This distinguishes it from the long sibling list, where no other tool claims to refresh the project cache.
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 phrase 'after file changes' provides a clear context for when the tool should be used. However, it does not name alternative tools or explicitly state when not to use it, so it stops just short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes that this is a read operation, and the description does not contradict it. The description adds useful context by limiting results to .tres files across the project, but it does not disclose behaviors such as recursion, project_path resolution, or whether the current project is required.
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 a single focused sentence with no filler. The verb and resource type are front-loaded, making the tool's purpose immediately clear.
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?
For a simple read-only tool with two optional documented parameters and an output schema, the description is nearly complete. It could briefly mention how project_path relates to the project scope, but the schema and annotations already cover most operational details.
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 input schema already documents both parameters with descriptions, so the baseline is 3. The tool description adds no additional parameter semantics beyond what the schema provides.
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 states a specific verb ('List'), a specific resource type ('.tres resource files'), and a scope ('the Godot project'). This clearly distinguishes it from sibling tools that list scripts or scenes.
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?
The description implies the tool should be used when an inventory of .tres files is needed, but it gives no explicit when-to-use guidance or comparison to alternatives like godot_get_project_files, godot_list_scenes, or godot_find_unused_files. Selection is left mostly to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With readOnlyHint=true, the read-only behavior is already communicated by annotations. The description adds that this lists all scripts in the project, but it does not disclose additional behavior such as recursion, ordering, or filtering, though the output schema may cover the return format.
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 a single front-loaded sentence that contains the necessary information (action, object, scope) and no filler. Every word earns its place.
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?
For a simple read-only listing tool, the description plus annotations and output schema provide a reasonably complete contract. It does not explain when to use an alternative tool, but the parameters and return values are covered by the schema.
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?
Schema description coverage is 100%, so both parameters are fully documented in the schema. The description does not need to repeat them; its omission of parameter details is acceptable.
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 states a specific action (List), a specific resource type (.gd script files), and a scope (the Godot project). This clearly distinguishes it from sibling tools like godot_list_scenes and godot_list_resources without needing extra context.
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?
The intended use is implied by the description: use it when you need to enumerate script files in a Godot project. However, it does not explicitly mention when to prefer this over alternatives such as godot_get_project_files or godot_find_by_pattern, nor does it state exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the safe-read nature is known. The description adds the parsing aspect, suggesting the tool returns structured script data rather than raw text. It does not discuss side effects, but none are expected for a read-only operation.
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 a single, tightly worded sentence with no filler. The verb and resource are front-loaded, and every word contributes to the meaning.
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?
For a low-complexity read-only tool, the readOnly annotation, fully described schema, and presence of an output schema cover most agent needs. The only minor gap is that it does not explicitly orient the agent away from sibling alternatives, but that is not essential given the tool's simplicity.
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?
Schema description coverage is 100%, with script_path and project_path both documented in the input schema. The description itself adds no parameter-specific detail, so it relies on the schema to carry that meaning.
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 names a specific verb ('read and parse') and a specific resource ('GDScript file'), making the action unambiguous. It also distinguishes from sibling tools like godot_read_scene, which targets scene files, and godot_list_scripts, which lists rather than reads.
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?
There is no explicit when-to-use or when-not-to-use guidance, nor any mention of alternatives. However, the plain purpose statement implies that this tool is for reading and parsing a .gd file, which provides minimal but sufficient use context for a straightforward read operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint=true, so the description adds useful behavioral nuance by saying files 'may not' be referenced, signaling that this is a heuristic analysis rather than a guaranteed determination. This helps the agent interpret results cautiously, though it does not detail scanning scope or limitations.
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 a single, front-loaded sentence with no filler or redundant information. Every word contributes to the meaning, making it easy for an agent to parse quickly.
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?
For a read-only, single-parameter analysis tool with an output schema, the description adequately states what the tool does and adds an important caveat about the heuristic nature of the results. It does not explain return values, but the output schema covers that, and no critical behavioral context appears 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 schema fully documents the sole optional parameter 'project_path' with 100% coverage, so the description does not need to add parameter details. The description itself adds no parameter semantics beyond what the schema already provides, matching the baseline for high schema coverage.
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 states a specific action ('Find') and a specific resource ('files that may not be referenced in scenes or scripts'). This clearly distinguishes the tool from generic file listing or search siblings like godot_get_project_files and godot_find_by_pattern.
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?
The intended use is implied by the name and description: identify potentially unused files during cleanup or review. However, there is no explicit guidance about when to prefer this tool over alternatives such as listing all project files or using find_by_pattern, nor are any exclusions or prerequisites mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no behavioral annotations beyond the title, the description carries the full burden and it does well by disclosing that no background file watcher exists and that returned paths are meant for manual monitoring or refresh. This is valuable beyond the schema. It could go further by stating whether paths are relative or absolute, but the core behavior is clear.
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 concise and well-structured: the core action is front-loaded, and the important caveat about no background watcher plus the recommended follow-up action appears immediately after. Every sentence earns its place.
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?
For a simple listing tool with fully documented optional parameters and an output schema, the description is quite complete. It covers the main operational caveat and usage pattern. A slight gap is the lack of explicit guidance for choosing this tool over closely related list tools.
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?
Schema description coverage is 100%, so each parameter is already well documented. The description adds only general context about file types and returned paths, not deeper parameter semantics. This meets the baseline without adding significant meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: list scene, script, and/or resource files in the project. It is specific about the resource types and implies monitoring/refresh use, but it does not explicitly differentiate itself from sibling list tools like godot_get_project_files or godot_list_scenes.
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 usage context: use the returned paths with your editor or call godot_refresh_project() after external changes. It also clarifies that no background watcher runs, which prevents misuse. However, it does not explicitly state when to prefer this tool over alternative list/search tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already indicates no mutation, and the description adds that the result is a unique ID string. However, it does not disclose details such as whether the ID is random, persistent, or scoped to the project; this is a minor gap given the simple, read-only nature.
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 very short and front-loaded, with each sentence carrying necessary information. The return type statement is useful and directly explains output, so there is no filler or wasted content.
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 tool with a read-only hint and an output schema, the description is sufficient. It states the action and the return value clearly, and there are no complex inputs, side effects, or usage conditions that need extra explanation.
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 accepts zero parameters, so there is no parameter burden to clarify. The description and schema are fully aligned, and the baseline of 4 for parameter-less tools is appropriate.
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 action: generating a unique ID for Godot resources, and specifies the return as a unique ID string. The verb 'Generate' plus the resource type makes the tool's purpose unambiguous, even without sibling differentiation.
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?
The description implies usage when a Godot resource UID is needed, but it does not explicitly state when to use this tool versus alternatives or mention exclusions. Since there are no obvious sibling tools doing the same thing, this is acceptable but still relies on inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no readOnly or destructive annotations, the description carries the behavioral disclosure burden. It does well by explaining that zip archives are extracted, nested addons are relocated, and editor plugins require manual enabling. It stops short of mentioning overwrites, network behavior, or failure modes, but the disclosed extraction behavior is substantial and useful.
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 front-loaded with the one-line summary, followed by a dense but necessary explanation of extraction and plugin placement. Every sentence earns its place, and there is no filler or redundant restating of the tool name.
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 description explains the critical behavior of the tool — extraction, addon movement, and plugin enabling — and an output schema exists, so return-value details are not needed. Minor gaps remain around prerequisites for asset_id and potential overwrite behavior, but the provided context is strong for a 3-parameter tool.
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?
Schema description coverage is 100%, so the schema already documents asset_id, project_path, and download_path clearly. The description adds little parameter-specific meaning beyond the schema, but that is acceptable because the schema covers the semantics.
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 a specific verb and resource: 'Download an asset from the Asset Library.' This clearly distinguishes the tool from sibling discovery tools like godot_search_assetlib and godot_get_asset_info, and leaves no ambiguity about what action it performs.
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 for the download workflow, including what happens after extraction and a verification step via godot_list_editor_plugins. It does not explicitly name alternatives or exclusion conditions, but the tool's purpose is distinct enough among siblings that the guidance is still effective.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the read-only safety profile is covered. The description adds the search-by-project.godot behavior, and the parameter description discloses the two-phase algorithm (walk-up first, fallback to workspace scan), which is genuine behavioral context beyond what annotations provide. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single efficient sentence with no filler: it names the verb, the resource, and the method in order. The more detailed search algorithm is appropriately pushed into the parameter description rather than cluttering the main description.
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?
For a simple, read-only tool with a single optional parameter that is fully documented and an output schema present, the definition is nearly complete. The only minor gap is that it doesn't state what happens when no project.godot is found (failure/empty result), but the output schema likely covers the return shape, and this is not critical for a safe read-only operation.
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%, so the baseline is 3. The parameter description goes beyond the baseline by explaining the default (MCP workspace root), the optional upward walk, and the fallback scan behavior. This adds real semantic meaning about how the path affects the search, earning a 4.
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 states a specific verb ('Find'), a specific resource ('the Godot project root'), and the distinguishing method ('searching for project.godot'). This clearly separates it from siblings like godot_find_by_pattern (pattern-based file search) and godot_list_projects (listing projects), so an agent can tell them apart without opening schemas.
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?
Usage is implied by the name and description: call this when you need to locate a Godot project root. The parameter description adds useful context about the search strategy (walk-up first, then workspace scan), but there is no explicit statement of when to prefer this over related tools like godot_find_by_pattern or godot_get_project_info, and no exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, and the description reinforces this by stating the tool lists rather than modifies, and that MCP does not edit [editor_plugins]. This adds useful behavioral context about why the tool is safe and why plugins won't be auto-enabled.
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?
Three concise sentences: what it does, when to use it, and why it does not modify editor plugins. The most important information is front-loaded and every sentence earns its place.
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?
With readOnlyHint present, an output schema present, and the single optional parameter fully documented in the schema, the description covers purpose, timing, and rationale. Nothing essential is missing for an agent to select and invoke this tool correctly.
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 input schema already fully documents the only parameter, project_path, as 'Optional project root'. The description adds no further parameter-level semantics, but the schema coverage is high, so the baseline of 3 is appropriate.
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 first sentence states a specific verb and resource: it lists addon folders with plugin.cfg and which editor plugins are enabled in project.godot. This clearly differentiates it from sibling tools like godot_get_project_settings or godot_list_autoload.
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 explicitly says when to use this tool: after the user enables plugins in the editor, to verify before continuing. It also names the companion tool godot_get_project_settings, but it does not explicitly describe when not to use it or compare it against alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no safety annotations beyond the title, the description carries the full disclosure burden. It explicitly reveals that files are written, that Godot's editor runs in headless import mode when both conditions hold, and that this is the engine's initialization step. It stops short of stating overwrite behavior or failure handling, which are relevant for a write tool.
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 core purpose is front-loaded in the first sentence, and the second sentence provides the only necessary nuance: the conditional import behavior. Both sentences earn their place with no filler or redundant restatement.
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?
For an 8-parameter tool with full schema coverage and an output schema, the description is largely sufficient: it explains the artifact, the optional external process, and the prerequisite environment variable. Remaining gaps such as overwrite behavior and failure handling are real but minor given the existing structured field coverage.
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%, so the baseline is 3. The description adds extra meaning for run_godot_import by tying it to GODOT_MCP_ALLOW_GODOT_EXEC=1, and for relative_path by anchoring it under the workspace. No other parameter needs description-level supplementation.
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 states a specific verb-resource pair (create a Godot project) and names the exact artifacts written (project.godot and a starter .tscn), which clearly distinguishes it from sibling tools like godot_create_scene or godot_create_script. It leaves no ambiguity about what this tool produces.
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 clearly frames the use case: creating a project under the MCP workspace, mirroring what the Project Manager does on disk. However, it does not explicitly say when not to use it or point to alternatives such as godot_refresh_project for existing projects, so exclusions are left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark readOnlyHint, and the description adds meaningful behavioral detail: search mechanisms (mdfind, where.exe, find, directory scan, PATH), OS-specific ordering, and return contents. It stops short of stating failure behavior or what happens when GODOT_EXECUTABLE is set, but there is no contradiction.
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 front-loaded with purpose, then uses compact OS-specific bullets that carry real operational information. Every line earns its place and the return type is stated clearly.
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 parameterless read-only lookup, the description is complete: it covers all platforms, the fallback order, and the return shape, while the output schema handles formal return typing. Nothing essential is missing.
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 zero parameters and schema coverage is complete, so there are no parameter semantics to document. The description still clarifies the implicit environment-variable input (GODOT_EXECUTABLE) and the resolution context, which is useful.
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 names the exact resource (the Godot executable) and a specific action (find), and adds OS-specific resolution order that makes it distinct from sibling search tools aimed at files, assets, or projects. It is immediately clear what this tool returns.
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 gives clear context by specifying behavior when GODOT_EXECUTABLE is unset and enumerating platform resolution strategies. It does not explicitly contrast itself with siblings or say when to call it before run/script tools, but the purpose is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description discloses that the workspace is a sandbox, that all writes/downloads are confined to it, and that changing GODOT_MCP_ROOT and restarting the server alters that root. This is meaningful behavioral context not present in the annotation.
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 compact, front-loaded with the core purpose, and every sentence earns its place: the sandbox definition, the path constraint, the environment/restart caveat, and the return summary. No filler or redundant schema 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 parameterless read-only getter with an output schema and readOnlyHint annotation, the description is complete. It explains what the tool returns, why the workspace root matters, and the only configuration dependency that changes its result.
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 zero parameters and the input schema is fully self-descriptive with 100% coverage. The description adds no parameter-specific detail, but none is required, so the baseline of 4 applies.
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 first sentence names a specific verb and resource: 'Return the sandbox directory for this server.' This unambiguously describes what the tool does and distinguishes it from siblings like godot_get_project_settings or godot_get_project_info, which target other kinds of project data.
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 gives clear contextual guidance: every project path, write, and Asset Library download must stay under this tree, so the agent knows this tool is relevant before path-dependent operations. It does not explicitly name alternatives or exclusions, but none are needed for a root-query tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already indicates this is a safe read operation, and the description adds useful behavioral context: it searches for project.godot files under the sandbox and lists workspace root plus {root, name} entries. This goes beyond the annotation without contradicting it.
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 short, front-loaded with the core action, then gives a focused usage condition and a compact return summary. Every sentence serves a purpose with no redundant or tangential content.
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 read-only list tool with an output schema present, the description covers what the tool does, when to use it, and what it returns. Nothing critical is missing for an agent to select and invoke it correctly.
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 zero parameters, so there is no parameter burden on the description. Schema coverage is 100% by having an empty properties object. The description's mention of the return shape supports understanding the tool's semantics.
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 states a specific verb ('List'), a clear resource ('every Godot project'), and an explicit scope ('under the MCP sandbox directory'). It also notes the meaningful distinction from needing to pick among several games, making the tool's purpose immediately understandable.
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 gives explicit conditions for use: 'when the MCP process cwd is not inside a project or you need to pick among several games.' This provides a clear context although it does not name a specific alternative tool to use instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![godot-mcp-server MCP server](https://glama.ai/mcp/servers/sterion66/godot-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/sterion66/godot-mcp-server)

Score Badge

Copy to your README.md:

[![godot-mcp-server MCP server](https://glama.ai/mcp/servers/sterion66/godot-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/sterion66/godot-mcp-server)

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/sterion66/godot-mcp-server'

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