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

The description discloses that import downloads files into res://assets/<provider>/<id>/ and rescans the project filesystem, which is meaningful behavioral context beyond the readOnlyHint=false and idempotentHint=false annotations. It does not mention overwrite behavior, network dependency, or auth, but the key side effect of import is clearly stated.

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

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

Two sentences carry the full purpose and usage: the first gives the high-level capability, the second breaks down each action with its specific behavior. It is front-loaded, contains no fluff, and every phrase adds information.

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

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

For a tool with three actions, two providers, and eight parameters, the description covers the end-to-end workflow well and gives concrete import destination details. It does not describe the return shape of search or import results, and there is no output schema, which is a minor gap for an agent relying on the returned asset id.

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

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

Schema description coverage is high (88%), so the schema already documents most parameters. The description adds workflow-level meaning by tying id/provider to preview/import and showing the import path, but it does not significantly elaborate on parameters like format, resolution, or limit beyond what the schema provides.

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

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

The description clearly states the tool's three verbs—search, preview, and import—and the resource (free CC0 3D assets from Poly Haven and ambientCG). It also explains the different purpose of each action, distinguishing this asset-management tool from the sibling godot_* tools.

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

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

The description gives a clear workflow: use 'search' to find candidates, 'preview' to choose by sight instead of guessing from an id, and 'import' to download into the project. It does not explicitly compare against alternative sibling tools, but within this tool the action-selection guidance is clear and practical.

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

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

Annotations already indicate destructive and non-idempotent behavior, so the bar is lower. The description adds meaningful behavioral context beyond annotations: node_path parameters can accept session handles that survive renames/reparents but go stale on scene reload, and async mode returns a job_id for long operations. This clarifies real operational edge cases.

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

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

The description is front-loaded with the core purpose, then guides the agent to the correct discovery tools, then explains the nontrivial handle behavior and async usage. Every sentence earns its place, and there is no redundant restatement of the schema or annotations.

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

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

For a generic dispatch tool with no output schema, the description is quite complete: it explains how to discover methods, how to get parameter schemas, how to handle long operations, and the special node_path handle semantics. It does not explicitly state that a non-async call returns the method's result, but this is largely implied and hard to specify generically.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds genuine value by explaining the special handle syntax for any node_path parameter, the async boolean's behavior, and pointing to godot_describe for method-specific params. This goes beyond what the schema alone communicates.

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

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

The description states a specific action ('Call any method') on a specific resource ('the Godot editor addon'). It also distinguishes itself from the sibling tools by pointing to godot_list_methods and godot_describe as exploration/preparation tools, making it clear godot_call is the execution entry point.

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

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

The description gives clear context: use godot_list_methods to browse and godot_describe for parameter schemas, and use async for long operations that would exceed the 30s timeout. However, it does not explicitly discuss when to prefer godot_call over other execution-like siblings such as godot_execute, so it lacks full exclusion guidance.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds useful context beyond those annotations by specifying what is returned: types, required/optional status, defaults, and annotations. This clarifies the tool's output scope without contradicting the safety hints.

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

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

The description is a single, well-structured sentence with no filler. It front-loads the action and resource, then packs the relevant detail about output contents and batch support.

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

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

For a simple introspection tool with one parameter and rich annotations, the description covers what the tool returns and what input it expects. It does not explain the exact response structure, but the phrase 'full parameter schema' with enumerated components is sufficient for an agent to call the tool correctly.

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

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

Schema coverage is 100% with a descriptive methods field, but the description adds meaning by clarifying that the method names are 'godot_call methods' and that the result is a full parameter schema. This helps an agent understand what to pass and what to expect, going slightly beyond the bare schema.

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

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

The description uses the specific verb 'Get' and names the exact resource: 'full parameter schema' for godot_call methods. It clearly distinguishes this tool from siblings like godot_call (execution) and godot_list_methods (listing), making the intent unambiguous.

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

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

The description implies the tool should be used when an agent needs parameter schema details for godot_call methods, but it never explicitly states when to use it versus alternatives, nor mentions exclusions. There is no direct comparison with sibling tools such as godot_list_methods or godot_call, so the agent must infer the selection logic.

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

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

Annotations already mark it read-only and idempotent, and the description is consistent with that by saying it diagnoses and suggests fixes rather than applying them. It adds useful behavioral context by enumerating the bridge layers inspected and the checklist/fix-suggestion output form.

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

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

The description is one dense sentence that front-loads the main action and resource, then uses a parenthetical list to communicate the scope without padding. Every clause contributes information.

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

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

For a no-parameter diagnostic tool with safety annotations, the description is complete: an agent knows what will be checked, what the output will look like at a high level, and that the operation is safe. No output schema exists, but the description's checklist/fix-suggestion statement gives enough expectation of return content.

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

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

With zero parameters, the schema is fully covered and no parameter documentation is needed. The description's specification of exactly what is diagnosed compensates for any lack of input details; baseline 4 applies.

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

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

The description opens with the specific verb 'Diagnose' and a concrete resource, 'the MCP bridge', then scopes it end-to-end with named layers (port, editor connection, auth, addon/server contract, Godot binary). This distinguishes it from siblings like godot_status or godot_info by promising a full diagnostic checklist plus fix suggestions.

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

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

It clearly conveys when to use it: when a full end-to-end diagnosis of the MCP bridge is needed, including port, connection, auth, contract, and binary. It stops short of explicitly naming alternatives or stating when not to use it, so no exclusions; that is why it doesn't get a 5.

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

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

The annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is explicit. The description itself adds no warning about arbitrary code side effects or a caution to use carefully; it only adds the shorthand routing detail, so it contributes limited behavioral context beyond the annotations.

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

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

One clean, front-loaded sentence conveys the core action and the parenthetical adds a useful routing note without filler. Every word earns its place.

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

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

For an arbitrary-code execution tool there is no output schema and no mention of return values, failures, or side-effect warnings beyond the annotation. It is sufficient to select and invoke, but for an execution primitive it leaves result/error behavior unspecified.

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

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

Schema description coverage is 100%; the code parameter already has a full description. The tool description does not add further parameter-level meaning, so it does not need to compensate and the baseline 3 applies.

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

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

Description states a specific verb and resource: 'Execute GDScript code in the Godot editor'. It also clarifies that this is a shorthand wrapper for godot_call method=execute_editor_script, which distinguishes it from the other godot_* siblings.

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

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

The description gives a clear usage context: this tool is the shorthand form for godot_call with method=execute_editor_script. It does not explicitly state when to avoid it or list alternatives beyond godot_call, so it misses a small amount of routing guidance.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds that it delegates to godot_call with method=get_project_info, which is mildly useful, but it does not describe what 'project info' contains or how the result is returned. With annotations covering the main behavior, this is adequate but not rich.

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

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

A single, front-loaded sentence that conveys purpose and the delegation relationship with no wasted words. It is appropriately concise for a zero-parameter tool.

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

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

For a zero-parameter, read-only info retrieval tool, the description provides enough to understand its role and invocation path. The lack of an output schema and any detail about the structure of 'project info' is a minor gap, but not critical for such a simple shorthand wrapper.

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

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

The tool has zero parameters, and schema description coverage is 100%, so there is no parameter burden for the description to carry. Baseline for zero parameters is 4, and the description adds no parameter-specific clutter.

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

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

The description uses a specific verb ('Get') and resource ('project info from the Godot editor'), and explicitly identifies itself as a shorthand for godot_call method=get_project_info, clearly distinguishing it from sibling tools. An agent can understand exactly what this tool does without inspecting schemas.

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

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

The description clarifies that this tool is a shorthand for a specific godot_call invocation, implying it should be used when the agent wants project info without crafting a full method call. It does not explicitly describe when to prefer godot_call or other siblings, but the convenience-wrapper relationship gives sufficient routing context.

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

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

Annotations already provide the safety profile (read-only, idempotent, non-destructive), and the description adds meaningful behavioral detail: the tool returns status first, then result or error once finished. This goes beyond the schema and annotations, though it leaves polling semantics implicit.

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

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

Two short, dense sentences lead with the action and then describe the result behavior. There is no filler or redundancy; every word contributes.

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

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

For a simple one-parameter, read-only tool with robust annotations, the description covers what it checks and what it returns. It does not detail status formats or polling behavior, but that is not essential for an agent to invoke it correctly.

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

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

The single parameter, job_id, is fully documented in the schema ('The job_id returned by godot_call'), so schema coverage is 100%. The description reinforces the linkage to godot_call but does not add new parameter-level meaning. Baseline 3 is appropriate.

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

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

The description clearly states the operation ('Check'), the resource ('an async job'), and the originating call ('godot_call with async:true'). This separates it from sibling tools like godot_call and godot_execute without ambiguity.

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

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

The description gives a clear trigger for using this tool: after starting an async job with godot_call's async:true. It does not explicitly list exclusion cases or name alternatives, but the intended usage context is unmistakable.

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

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

Annotations already establish safe read-only, idempotent behavior. The description adds meaningful behavioral context: results are 'live from the connected editor' and output differs based on whether a category is supplied. No contradiction with annotations.

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

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

Two concise sentences with no filler. The core purpose is front-loaded, and the two usage modes are clearly separated. Every sentence earns its place.

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

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

For a simple single-parameter listing tool, the description is complete: it states what is returned in both invocation modes, and the annotations cover safety and side-effect behavior. No output schema exists, but the description adequately conveys the shape of results.

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

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

The schema already covers the single optional parameter at 100%, including examples. The description reinforces this by explaining the no-argument vs. with-category behavior and reiterates the discovery workflow, adding value beyond the raw schema.

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

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

The description states a specific verb and resource: 'List available Godot addon methods, live from the connected editor.' This is clear and unambiguous, though it does not explicitly differentiate itself from sibling tools like godot_describe or godot_info.

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

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

The description gives concrete call patterns: 'Call with no arguments for category counts, or with a category to list its methods and one-line summaries.' However, it does not explain when to choose this tool over alternatives or mention scenarios where another sibling would be more appropriate.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds only the output format and does not disclose conditions like whether the editor must be running or whether the capture can fail, but this is acceptable 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.

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

Two short sentences with the action and target front-loaded, followed by the return format. There is no filler, repetition, or irrelevant information.

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

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

For a no-parameter, read-only tool with annotations covering the safety profile, this description is complete enough for an agent to select and invoke it. It names the action, the target, and the output encoding, so no critical information is missing.

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

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

The input schema has zero parameters, so there are no parameter semantics to document. The 0-params baseline applies, and the description neither adds nor needs parameter details.

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

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

The description states a specific action ('Capture'), a specific target ('the Godot editor viewport'), and a concrete output contract ('Returns base64 PNG image data'). This clearly differentiates it from sibling tools like godot_execute or godot_status, which handle actions or status rather than visual snapshots.

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

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

The description makes the use case obvious: use it when a visual snapshot of the editor viewport is needed. It does not explicitly name alternatives or exclusions, but no sibling tool appears to compete with screenshot functionality, so the omission is minor.

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

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

Annotations already provide idempotentHint=true and destructiveHint=false. The description adds useful behavioral context by disclosing that the 'select' parameter pins a specific editor for subsequent calls when multiple editors are connected. It does not contradict the annotations.

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

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

The description is two sentences with no filler. The primary purpose is stated first, and the optional selection behavior is added in the second sentence without redundancy.

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

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

For a simple tool with one optional parameter and no output schema, the description is nearly complete: it states the core function and the selection side effect. A minor gap is that it does not describe what the status output includes, but this is not critical given the lack of an output schema.

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

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

The schema already documents 'select' as a project name or path fragment for pinning an editor. The description adds the condition 'when several are connected', clarifying the situational effect of the parameter beyond the raw schema.

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

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

The description uses a specific verb ('Check') and resource ('connection status to the Godot editor'), and also describes the optional 'select' behavior that pins an editor. This distinguishes it from sibling tools like godot_info or godot_execute, 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.

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

The description implies when to use the tool: to check connection status and optionally select which editor subsequent calls target. However, it does not explicitly state when to prefer this over siblings or provide exclusion criteria, leaving some usage context to inference.

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