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

Annotations declare readOnlyHint=false, and the description's 'Execute scene mutations' aligns. The description adds behavioral details (pre-check, post-verify, optional save) beyond annotations, but doesn't explain what these steps entail, failure behavior, or reversibility. It adds some transparency but not rich context.

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 very concise and front-loaded, but the stray '1.' on the second line is a formatting artifact that adds noise and undermines structural quality. It could be a single clean sentence without the artifact.

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

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

Given the empty schema and minimal annotations, the description covers the core behavior but lacks context about how it relates to sibling tools (e.g., whether it requires a plan), what 'optional save' means, and what happens on pre-check failure. It is minimally viable but not complete for an execution tool.

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 the baseline is 4. The description appropriately avoids inventing parameter details, and no parameter documentation is needed.

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 action verb 'Execute' and clearly identifies the target as 'scene mutations', with qualifiers (pre-check, post-verify, optional save) that help distinguish it from planning or verification tools. However, it doesn't explicitly name sibling alternatives, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like scene_change_plan or verify_after_change. It does not state prerequisites, exclusions, or recommended workflow context, leaving the agent without usage direction.

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?

Beyond the readOnlyHint annotation, the description reveals important behavioral traits: it blocks until compilation and reload finish, handles domain reload disconnects transparently, and provides a fallback mechanism based on sync_status. These are non-obvious behaviors that help the agent understand what to expect, without contradicting 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.

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

The description is compact yet packed with essential information. It front-loads the primary purpose, then gives usage guidance, return format, edge cases, and internal behavior in just a few sentences. Every clause earns its place, with no wasted words.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description is remarkably complete. It explains the return value ('errors or 'compile clean (Xs)''), the blocking nature, domain reload handling, timeout behavior, and fallback logic. The agent has enough context to use it correctly in various situations.

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 provides a baseline (100% coverage) for the 'timeout' parameter, but the description adds valuable semantics: 'timeout=0 → immediate check, no loop' clarifies the effect of a zero value, which is not in the schema. This extra context justifies a score above the baseline.

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 function: 'Block until Unity finishes compiling + reloading, then return compile errors.' It uses a specific verb and resource, and distinguishes itself from siblings like get_compile_errors by focusing on the waiting/blocking behavior and returning compile status. The phrase 'Use after writing .cs files instead of sleep' further clarifies its unique role.

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?

Explicit guidance is given: 'Use after writing .cs files instead of sleep.' It also explains edge-case usage with 'timeout=0 → immediate check, no loop' and mentions fallback behavior ('falls back to compile_status'), giving clear context on when and how to invoke the tool. This effectively differentiates it from alternatives.

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 description discloses important behavioral traits beyond the minimal readOnlyHint annotation: atomic reverts prior ops via Unity Undo, execute_code filesystem side-effects are not reverted, and on_error behavior is defined. It does not cover return format or permissions, but the core side-effect behavior is well addressed.

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 three sentences, front-loaded with the purpose and usage. It packs essential details (command format, error handling, timeout, atomic behavior) without redundancy. 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?

Given the tool's complexity and the absence of an output schema, the description provides substantial context: command format, error behavior, timeout, atomicity, and side-effect caveats. It does not describe the return value format, which is a minor gap, but overall it is comprehensive enough for agent use.

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 already covers all five parameters with detailed descriptions, so the baseline is 3. The description adds a generic command syntax ('cmd key=value') but largely duplicates the schema's examples and does not significantly enhance parameter understanding 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 'Execute multiple commands in one call' with a specific verb and resource. It distinguishes itself from individual tool calls by noting 'Use for 2+ ops — reads AND writes' and 'PREFER over individual tool calls'.

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 explicitly states when to use the tool ('Use for 2+ ops') and provides a clear preference over alternatives ('PREFER over individual tool calls'). It also explains key options like on_error and timeout, guiding selection and configuration.

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?

Discloses that the tool does not write or recompile (consistent with readOnlyHint=true) and adds valuable return behaviors: 'OK preflight (ms) / ERR preflight + diagnostics / [ROSLYN UNAVAILABLE]'. It also reveals the Roslyn dependency and typical latency, going beyond the basic annotation.

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?

Every sentence serves a purpose: purpose, when to use, parameter semantics, and return format. The description is compact, front-loaded with the key differentiator, and contains zero filler.

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 two-parameter read-only tool, the description covers the core needs: what it does, when to use it, parameter meanings, and return values. It leaves minor ambiguity about the structure of diagnostics and how to respond to 'ROSLYN UNAVAILABLE', but overall it is sufficient given the simple tool signature.

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's properties have only titles (no descriptions), so the description provides essential semantics: 'file_path: Assets-relative' and 'new_content: full file'. This adds meaning that the schema lacks, though it stops short of giving examples or value formats.

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 ('Validate') with a clear resource ('C#') and immediately distinguishes itself from siblings by noting it does so 'WITHOUT writing/recompiling (Roslyn)'. This contrasts with compile/error tools like get_compile_errors and await_compile, making its unique purpose 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?

Explicitly states 'Use before writing .cs' and provides a performance comparison (~200ms vs 30s recompile), giving clear context for when to invoke it. It does not name alternative tools or explicitly say when not to use it, but the intended use case is strongly implied and sufficient for an agent.

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, so the read-only safety is covered. The description adds value beyond that by specifying the return behavior (mark_id encoding timestamp), the pure Python implementation (no TCP call), and the intended usage pattern. This is useful context not derivable from annotations alone.

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 extremely concise: three short sentences, each carrying essential information. It is front-loaded with the primary purpose, followed by return value, usage, and implementation detail. No filler or redundant wording.

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 one optional parameter, no output schema, and readOnly annotation, the description covers most key points: what it does, what it returns, and how to use it. However, the lack of any explanation of the 'label' parameter and the absence of any mention of edge cases or error conditions leaves a small gap, preventing a perfect score.

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 only parameter 'label' has no description in the schema (coverage 0%) and the tool description completely omits it. The description must compensate for low schema coverage, but it fails to explain what 'label' is for (e.g., an optional identifier for the mark). This leaves a notable gap for a parameter that is present, even if optional.

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 ('Create') and resource ('console watermark'), and clearly explains the function: returning a mark_id encoding the current timestamp. It distinguishes itself from sibling tools like get_console_since by describing the relationship (pass the mark to retrieve logs after that 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?

Provides explicit usage context: create a mark, pass it to get_console_since() to filter logs. Also notes 'Pure Python — no TCP call', which implies it is a lightweight option compared to network-based tools. This gives clear when-to-use guidance and even hints at an alternative.

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 description discloses creation modes (primitive, prefab, components) and scene behavior, which goes beyond the minimal readOnlyHint annotation. However, it omits important behavioral details like the precedence when both primitive and prefab_path are provided, and it does not mention any side effects such as selection or undo. Given the lack of thorough annotations, this is a noticeable gap.

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 compact and front-loaded with the core purpose. It uses a concise field: explanation format, but several sentences are redundant with the schema, slightly reducing efficiency. Overall, it is appropriately sized and easy to scan.

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

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

Given the schema is rich and fully descriptive, the description covers the main creation options and scene handling. It omits the parent parameter but that is well-documented in the schema. No output schema exists, so return values are not expected. The description is complete enough for an agent to invoke the tool correctly in most scenarios.

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 100% parameter description coverage, so the baseline is 3. The description essentially restates the schema's parameter descriptions (e.g., 'components: comma-separated types to add on creation' is nearly identical to the schema text) and adds no new semantic detail. It does not help beyond what the schema already 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 'Create new GameObject' with a specific verb and resource. It distinguishes itself from sibling tools like delete_object and manage_component by focusing on the creation of new objects, which is 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 gives clear context for when to use the tool: when creating a new GameObject via primitive, prefab, or with components. It does not explicitly mention alternatives or exclusions, but the context is strong enough to guide the agent without confusion.

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 state destructiveHint=true and readOnlyHint=false, so the destructive nature is known. The description adds context that the target can be identified by instance ID or scene path, which is useful. However, it does not disclose details like permanence, effects on children, or required authentication.

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

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

The description is a single sentence, front-loaded with the verb 'Delete', and contains no fluff. Every word adds meaning, making it concise and well-structured.

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

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

Given the tool is simple and has annotations, the description covers the core function. However, it lacks details about return values, error handling, or behavioral nuances like whether the deletion is recursive or irreversible, and the empty schema leaves input structure unexplained.

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 properties, so the baseline for parameter semantics is 4. The description partially compensates by indicating the identifier types (instance ID or scene path), but it does not specify parameter names, formatting, or how to pass these arguments, leaving ambiguity for the agent.

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 'Delete' and resource 'GameObject', and clarifies the target via 'instance ID or scene path'. This clearly distinguishes it from sibling tools like create_object and set_property.

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

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

No guidance is provided about when to use this tool versus alternatives, nor any exclusions or prerequisites. The usage is only implied by the function itself, and the description does not mention related tools or conditions.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the effect of each flag: include_legacy adds aliases, structured adds surface/mutability info, and enable=False toggles to browse mode. This goes beyond simple operation naming and gives the agent insight into mutability implications and output richness.

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, front-loaded with the core purpose, and the subsequent sentences efficiently enumerate canonical categories and parameter semantics. No filler or redundancy; every clause adds value.

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

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

Given four parameters, no annotations, and no output schema, the description covers the tool's purpose, categories, and parameter behaviors well. It doesn't explicitly describe the return format, but the mention of 'structured=True adds surface/mutability info' hints at output shape, making this a solid, complete description.

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 0%, so the description fully compensates. It explains 'category' via the canonical 8 list, and interprets 'include_legacy,' 'structured,' and 'enable' with meaningful behavioral detail (e.g., 'enable=False to browse only'). Every parameter receives descriptive context that the schema lacks.

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 function: 'Find and enable tools by category.' It identifies a specific verb (find/enable), a resource (tools by category), and distinguishes itself from sibling tools that perform scene operations, validation, or compilation. The canonical category list further sharpens the tool's scope.

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 provides clear context for when to use the tool—when discovering or enabling tools by category—and explains key behavioral switches like 'enable=False to browse only.' It doesn't explicitly reference alternatives or exclusions, but the distinct purpose relative to siblings makes usage intuitive.

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 declare readOnlyHint=false, so the agent knows this can mutate state; the description adds the specific actions (play/pause/stop/select) as context. However, it does not disclose side effects (e.g., entering play mode may trigger compilation) or what information the 'state' action returns, leaving behavioral gaps beyond 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.

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

The description is two sentences with zero filler. It front-loads the purpose and packs the essential usage details for the select action into a compact form, making every word useful.

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 control tool with no output schema and sparse annotations, the description omits important details like return values for 'state' and the consequences of play/pause/stop. It is not completely hollow, but leaves gaps in what the agent should expect after invocation.

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 description enriches the schema by explaining that 'select' uses 'path' for single targets and 'paths' for comma-separated multiple targets (with an example). It also enumerates allowed action values. This goes beyond the basic schema descriptions, though it does not clarify the 'project_path' action fully.

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 controls editor state/playback and selection, listing specific actions (state, play, pause, stop, select, project_path). This distinguishes it from many sibling tools, though the phrase 'Editor state/control' is somewhat generic without the action list.

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?

There is no explicit guidance on when to use this tool versus alternatives like set_active or scene. It does imply usage by describing the select action for paths, but lacks clear context or exclusions such as 'for scene inspection use get_hierarchy instead'.

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 description discloses important behavior: security restrictions (no System.IO, System.Net, System.Diagnostics), auto-wrapping of bare statements, and shows an example. Annotations indicate readOnlyHint: false, which is consistent with executing code. While it does not mention side effects or undo behavior, the security and auto-wrap details add significant transparency beyond 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.

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

The description is compact and well-structured: it opens with the core purpose, follows with security constraints, then clarifies auto-wrapping, and ends with a concrete example. Every sentence provides useful information 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 code execution tool without an output schema, the description covers the essential behavioral context: what code can be run, restrictions, execution speed, and a usage example. It does not explicitly mention error handling or return values, but given the tool's open-ended nature and sibling context, it is sufficiently complete 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?

Schema coverage is 100%, so both parameters (code and undo_label) are already documented. The description adds value by explaining code auto-wrapping and providing an example, but does not elaborate on undo_label beyond the schema. Baseline 3 is appropriate since schema handles parameter semantics adequately.

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 executes C# code in the Unity Editor via Roslyn, with a specific resource (Unity Editor) and verb (Execute). It also distinguishes itself from sibling tools by highlighting its speed advantage over recompilation.

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 provides clear context on when to use this tool: for fast iterative code execution (10-40x faster than recompile). It implies an alternative (recompile) but does not explicitly say when not to use it or name alternatives. The speed comparison gives practical guidance for selection.

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?

With readOnlyHint=true in annotations, the description adds valuable context by noting that errors persist across Console.Clear() and that they are structured/typed. This goes beyond the annotation and helps the agent understand reliability and data format, though it doesn't detail edge cases like whether a compile is triggered.

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 deliver all essential information: what is returned, the format, and a key behavioral distinction. No filler or redundant content; every word adds value.

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 tool with no output schema, the description is mostly complete: it states the content, format, and persistence. However, it is slightly ambiguous whether the tool triggers a compilation or merely returns the latest available errors. Given sibling names like compile_preflight, this could matter, so completeness is high but not perfect.

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, so the baseline is 4 per rubric. There is no schema information to augment, and the description appropriately omits 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 clearly states the tool retrieves compilation errors with file:line:column notation. This is a specific verb+resource definition that distinguishes it from console-related tools like get_console by emphasizing structured, typed output.

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

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

The description implies usage for obtaining compile errors in a persistent structured format ('Not lost on Console.Clear()'), but it does not explicitly explain when to choose this over sibling tools like compile_preflight, await_compile, or get_console. No alternatives are named, so guidance is implied rather than explicit.

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 readOnlyHint annotation already establishes that this is a safe read operation. The description adds context about field projection ('shows requested fields even at default values') and the effects of 'full' and 'compress' flags, though the latter two largely mirror the schema descriptions.

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 well-structured with separate lines for alternatives and parameters. It is efficient, though the 'full' and 'compress' explanations partially duplicate the schema descriptions. Still, every sentence contributes to understanding.

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

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

Given the tool's moderate complexity (5 parameters, no output schema, readOnly annotation), the description covers purpose, usage alternatives, parameter semantics, and behavioral flags. The return format is implied as key-value pairs, which is sufficient for a getter tool.

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%, but the description adds significant value for the 'fields' parameter by listing aliases (e.g., position, rotation, scale) and clarifying that requested fields are shown even at default values. The other parameters are adequately described in the 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 clearly states the tool's function: 'Component properties as key-value.' It distinguishes from sibling tools by explicitly noting that inspect should be used for multiple objects, making the single-object scope obvious.

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?

Provides explicit guidance on when to use this tool versus an alternative: 'For MULTIPLE objects, use inspect(paths='a,b,c') instead — 1 call vs N.' Also explains the intended use of the 'fields' parameter to save tokens.

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 provide readOnlyHint=true, so the read-only nature is covered. The description adds useful behavioral details: keyword is a case-insensitive substring filter, count_only returns N matches as a string, and since filters by last N seconds. These go beyond the schema, providing clarity on how the tool behaves.

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?

Three concise sentences, front-loaded with the core purpose. Every sentence earns its place: purpose, exclusion, and parameter semantics. No filler or 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?

The description is sufficient given the tool's complexity: 6 parameters, no output schema, and readOnlyHint annotation. It covers all filter options and the alternative tool. It doesn't describe the return format for non-count_only calls, but that is a minor gap given the intuitive nature of console logs.

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 covers count, first, and level with descriptions, but the description adds meaning for keyword, count_only, and since—parameters that lack schema descriptions. This fills the gap and achieves comprehensive parameter understanding, though not all parameter semantics are described in the description itself.

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 the tool returns 'Recent console logs' and explicitly distinguishes it from get_compile_errors for C# compile errors. This gives a specific verb+resource (retrieves console logs) and clear differentiation from a sibling.

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 directly tells the agent when to use this tool (for recent console logs) and when not to ('For C# compile errors use get_compile_errors instead'). This is explicit and actionable.

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 mark this as readOnlyHint=true, so no mutation disclosure is needed. The description adds useful behavioral details: it filters by level and keyword, count_only returns a count as a string, and count has a default of 500. This goes beyond simple read-only and provides meaningful operational context.

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 compact bullet list, with the core purpose in the first sentence. Every line adds value and there is no filler.

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?

The tool has 5 parameters and no output schema, but the description covers all parameters and the count_only return type. It doesn't describe the full return structure for normal calls, but given the sibling context and simple nature, this is sufficient. Could be slightly more explicit about return format, but overall complete.

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

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

With schema description coverage at 0%, the description carries full burden for parameter meaning. Each parameter is explicitly explained: mark_id accepts a mark string or timestamp, level filters by allowed values, keyword is case-insensitive, count_only returns a string, and count has a default. This exceeds schema information.

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 a clear verb phrase 'Console entries after the watermark' which specifies exactly what the tool retrieves. It distinguishes itself from sibling tools like get_console and console_mark by referencing the mark-based scoping.

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 explains when to use this tool: to retrieve console entries after a watermark created by console_mark() or a timestamp. It implies an alternative to get_console but doesn't explicitly state exclusions or when to prefer alternatives, so it provides clear context without explicit alternative 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?

Beyond the readOnlyHint annotation, the description discloses important behaviors: max 3000 nodes, token-saving options (components, compress, summary token estimate), incremental returning NO_CHANGE, and full bypassing distillation. No contradictions 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?

The description is about six sentences, front-loaded with a clear purpose, then an alternative, followed by parameter guidance. Each sentence is informative, though the run of 'Set X=true' imperatives is slightly dense but justified by token-saving tips.

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

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

With no output schema, the description explains output types (text tree, summary counts, NO_CHANGE) and limits (3000 nodes). It covers all key params and their usage contexts, making it complete for a tool with 9 parameters and no explicit return structure.

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 covers all 9 parameters (100% coverage), so baseline is 3. The description adds value by explaining the purpose of filter/depth for narrowing, giving token estimate for summary, and clarifying compress grouping. However, it doesn't mention the root parameter or add detail for full, but schema already covers those.

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 'Scene hierarchy as text tree', clearly stating the tool's output format and purpose. It explicitly distinguishes from the sibling tool search_scene by directing users to use search_scene for finding specific objects by name/type.

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?

Provides an explicit alternative: 'For finding specific object by name/type use search_scene.' It also gives practical usage advice such as 'Use filter/depth to narrow' and explains when to enable flags like components, compress, summary, and incremental.

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 only include readOnlyHint=true, so the description carries the burden of explaining behavior. It discloses key operational traits such as automatic path population via find_type, field projection to save tokens, distillation bypass with full=True, and compression stripping default values. These go well beyond the annotation and materially inform the agent.

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 primary purpose and follows with terse, information-dense parameter explanations. Every sentence contributes value without redundancy, making it appropriately sized for the complexity.

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

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

Given no output schema, the description could be more explicit about the return structure, but it adequately covers all parameters, behaviors, and defaults needed for correct invocation. The operational context (batch read, token saving, compression) is well handled, so the minor lack of return-shape detail costs a point.

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?

Although the schema already describes all 6 parameters with 100% coverage, the description adds meaningful usage semantics: it explains comma-separated formats, defaults ('default: all'), interaction between find_type and paths, and the purpose of fields/compress (token and size reduction). This enriches understanding beyond the 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 opens with 'Get components for multiple objects at once', which clearly identifies the verb, resource, and scope. It distinguishes from sibling tool get_component by emphasizing support for multiple objects, making the tool's purpose unmistakable.

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 a batch inspection use case ('multiple objects at once') and explains parameter choices, but it does not explicitly name alternatives or exclude scenarios. This is clear context without formal when/when-not guidance, so a 4 is 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?

The readOnlyHint annotation already declares this as read-only; the description repeats that and adds the 'linter' behavior and the path input context. It does not disclose what the linter produces or any edge-case behavior, but given the annotation, this adds moderate value.

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 first sentence is concise and front-loaded, but the second sentence is truncated ('...fil…') and presented as a bare 'path:' line, which undermines the structure. The overall length is appropriate, but the incomplete second line reduces clarity.

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

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

Given the empty schema, readOnlyHint annotation, and no output schema, the description still does not explain what the linter returns, what it checks, or whether the path is required. Combined with the path/schema mismatch, the context is incomplete for safe invocation.

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 description mentions a 'path' argument with project-relative path semantics, but the input schema has no properties and additionalProperties is false. This mismatch means the agent cannot correctly pass the described path, making the parameter guidance misleading rather than helpful.

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 it is a read-only linter for scene references in DSL scripts or batch commands, giving a specific verb and resource. It is not a tautology, but it does not explicitly contrast with the sibling validate_references, so it stops short of full distinction.

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 context: linting scene references in DSL scripts or batch commands. It does not, however, state when to prefer this over validate_references or run_playtest, nor does it mention exclusions, so it lacks explicit when/when-not 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 only include readOnlyHint:false, so the description adds 'Mutates scene' and 'No confirmation required', disclosing the immediate mutation side effect and lack of a confirmation prompt. This goes beyond the annotation's simple non-read-only flag.

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?

Three compact sentences, front-loaded with the core action and mutation warning, followed by essential constraints. Every sentence earns its place without repetition.

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 3-param mutation tool with no output schema, it covers purpose, side effects, and constraints. It doesn't mention return values or error behavior, but these are less critical for a straightforward add/remove operation.

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% and every parameter (path, type, action) already has a detailed description. The description repeats the action constraint and type examples, adding no new semantic value beyond the 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?

States 'Add or remove a component' and 'Mutates scene' — a specific verb and resource. Clearly distinguishes from sibling tools like get_component (read) and set_property (property modification).

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?

Explicitly says action must be 'add' or 'remove' ONLY and directs to use set_property with prop='m_Enabled' for enable/disable. Also clarifies type format with short/full namespace examples.

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 description adds value by enumerating the fields included in the status (scene, dirty, play/compile state, port, alias count). Since readOnlyHint is already present in annotations, the read-only behavior is covered. However, it does not disclose any additional behavioral traits (e.g., whether it refreshes state, requires Unity connection, or how the status is computed).

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, tightly packed sentence that front-loads the key information. Every word contributes: 'Compact' indicates scope, and the colon-delimited list specifies exact content. No filler or repetition.

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

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

With no output schema, the description must convey what is returned. It lists the fields, but does not explain their meaning or possible values (e.g., what 'dirty' means, what 'port' refers to, or what 'play/compile state' looks like). For a simple status tool, this is adequate but leaves room for ambiguity.

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, so the schema provides no parameter information. Per the 0-param baseline, the description does not need to compensate for missing parameter semantics. The description's focus on output fields is appropriate here.

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 identifies the tool as providing a compact MCP status with specific fields (scene, dirty, play/compile state, port, alias count). It is distinct from sibling tools focused on console output or compilation errors, though it does not explicitly use a verb like 'get' or 'show'. The resource is 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?

No guidance is given on when to use this tool versus alternatives. The description simply states what the tool returns, leaving the agent to infer that it is for status checks. No exclusions or alternative tool mentions are provided.

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 description only says it handles permission prompts, but does not disclose what actions are taken (e.g., showing a prompt, approving/denying) or any side effects. Annotations only provide readOnlyHint, so the description carries the burden but falls short.

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 visible description is short and front-loaded with the core purpose. However, the second sentence is truncated, leaving the text incomplete, which slightly reduces structure quality.

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?

The tool lacks an output schema and provides minimal behavioral info. It does not explain what the permission prompt shows, how it resolves, or the return format, making the description incomplete for an agent to understand the full tool behavior.

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?

There are zero parameters, and the schema is empty. Per the rubric, a baseline of 4 is appropriate since no parameter documentation is needed.

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 explicitly states it handles Claude permission prompts via MCP, which is a specific verb+resource. It distinguishes itself from the sibling Unity tools, though the verb 'handle' is somewhat generic.

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 notes the tool is registered as --permission-prompt-tool so Claude routes all permission prompts to it, implying automatic usage. However, it does not mention alternatives or when not to use it.

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 idempotentHint=true and readOnlyHint=false, providing some safety and mutability context. The description adds that port 0 or omitted triggers auto-discovery from port files, which is useful behavioral information. However, it does not elaborate on potential side effects (e.g., whether an existing connection is closed) beyond the annotation hints, so the disclosure is adequate but not rich.

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

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

The description is extremely concise, consisting of a single direct sentence plus a short parenthetical note. It is front-loaded with the primary action and contains zero redundant or filler content. 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?

With no parameters, no output schema, and simple tool behavior, the description covers all essential aspects. The combination of the clear purpose and the port auto-discovery note is sufficient for an agent to understand and invoke the tool correctly. Annotations further round out the context, so nothing critical 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 the baseline is 4. The description adds meaningful context about port handling ('Port 0 or omitted = auto-discover from port files'), which clarifies how connection settings are resolved even though no explicit parameters exist. This goes beyond the schema by explaining the auto-discovery mechanism, though it is slightly ambiguous given the empty 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 clearly states the tool's action ('Reconnect') and resource ('Unity'), making its purpose unambiguous. The verb 'reconnect' distinguishes it from siblings like 'sync_unity' or 'discover_tools', which are about synchronization or discovery rather than connection. It is specific and actionable.

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

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

The description implies the tool is for re-establishing a connection to Unity, but it does not explicitly state when to use it (e.g., after a disconnect) or when to prefer an alternative. The note about port auto-discovery gives operational context but no comparative guidance against siblings. While the name and description are self-explanatory, explicit usage scenarios or exclusion criteria are absent.

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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states that schemas are returned, but does not mention potential errors (e.g., unknown tool names), side effects, or whether the tool queries live or cached data. This is insufficient for a tool with no annotation 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 extremely concise, with two short sentences that front-load the primary action and then specify the parameter format. No unnecessary words or 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?

The tool is simple (one parameter, no output schema), so the description covers the basic behavior. However, it omits context about what 'deferred tools' are, what the output format looks like (e.g., JSON structure), and how failures are handled. A bit more detail would make it complete.

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

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

The description explicitly explains the 'tools' parameter as 'comma-separated names', which adds meaning beyond the schema's bare 'string' type. This clarifies the format and intended usage, though it could also mention that these names refer to deferred tool identifiers.

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 returns full parameter schemas for deferred tools, using a specific verb ('Return') and resource ('parameter schemas'). It distinguishes itself from siblings like discover_tools by explicitly focusing on 'deferred tools', though the term 'deferred' is somewhat vague.

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

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

No guidance is provided on when to use this tool versus alternatives like discover_tools or mcp_status. The mention of 'deferred tools' implies a use case, but the description does not explain what deferred tools are or when resolution is needed.

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 provide readOnlyHint=false, already signaling mutation. The description adds context by mentioning Play Mode, structured report, and listing DSL commands that imply state changes (SET, INVOKE, TELEPORT). It doesn't specify report contents or side effects, but adds value beyond 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.

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

The description front-loads purpose and exclusions, then lists DSL commands in a compact, pipe-separated format. It's long but information-dense; the command list is essential for understanding script/defs parameters.

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

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

Given the tool's complexity (9 params, 20+ DSL commands, no output schema), the description covers the DSL thoroughly and defers parameter details to the schema. The main gap is the lack of detail about the structured report's format, but this is not critical for invocation.

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 baseline is 3. The description enriches the `script` and `defs` parameters by enumerating the DSL commands, giving the agent concrete syntax knowledge that the schema lacks.

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 '[Play Mode] Execute a playtest DSL script', using a specific verb and resource. It clearly distinguishes from run_tests by stating 'for NUnit tests, use `run_tests`'.

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 explicitly names an alternative for NUnit tests: 'for NUnit tests, use `run_tests`'. This provides a clear when-not and directs the agent to the correct sibling tool.

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 description discloses key behavioral traits beyond the readOnlyHint=false annotation: it enters Play Mode, requires no confirmation, and describes how stop_after exits Play Mode. It also explains the output format. This provides useful operational context that annotations do not cover.

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 well-structured with an overview, parameter breakdown, and output summary. It is sufficiently detailed but not overly verbose; each sentence contributes to understanding the tool's behavior or parameters.

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 7 parameters and no output schema, the description covers most aspects: the parameter relationships, the output shape, and the action. It lacks an explicit usage context compared to alternatives, but the information provided is sufficient for an agent to invoke the tool correctly. The missing timeout_per_test description is the main gap.

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

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

With 0% schema description coverage, the description compensates well by explaining the format and accepted values for pattern, suite_path, and the boolean flags (stop_on_fail, stop_after, auto_play, restart_between). However, the timeout_per_test parameter is not described at all, leaving a gap for that parameter.

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 runs multiple .playtest files sequentially and returns a compact matrix. It explicitly mentions entering Play Mode, which is a specific action. It distinguishes from siblings like 'run_playtest' by indicating batch execution of multiple files.

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 provides clear parameter usage guidance, including the constraint that exactly one of pattern or suite_path must be provided, and explains the effect of each flag. However, it does not explicitly state when to choose this tool over alternatives like 'run_playtest' or other test runners; the usage context is implied rather than stated.

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 description goes well beyond the idempotentHint annotation by disclosing the exact success response format, the START-UNKNOWN failure mode, and the correct resolution strategy (reusing the same request_id). This is critical behavioral information that an agent needs to handle dispatch reliably.

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 four concise lines, front-loaded with the core purpose. Every sentence adds value: the action, the success format, and the failure handling. No filler or redundant 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?

With no output schema, the description compensates by specifying the response protocol. It covers the main dispatch flow and the transport-failure edge case. However, it does not mention how to check results later (e.g., via run_tests_wait), leaving a slight gap in the overall workflow for a dispatch-only tool.

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 meaning for request_id by explicitly tying it to the START-UNKNOWN resolution flow, and it mentions run_id and utf_guid in the response, reinforcing the durable identity concept. It does not explain mode or filter beyond the schema, but the added context for request_id elevates it.

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 action ('Dispatch Unity tests') and the distinctive outcome ('return their durable identity immediately'). This differentiates it from the sibling run_tests_wait by emphasizing the immediate, async nature of the dispatch.

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

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

The description implies usage for asynchronous dispatch and provides operational guidance on handling START-UNKNOWN, but it does not explicitly contrast with alternatives such as run_tests_wait or state when not to use this tool. The guidance is more about handling edge cases than selecting between tools.

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?

Beyond the readOnlyHint: false annotation, the description reveals critical behaviors: no confirmation required, transport failures and domain reloads do not erase the last snapshot, and a caller timeout is observational—returning TIMEOUT with run data without marking the run complete. These details are valuable for agent decision-making and go well beyond annotation 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 compact, with a clear first sentence followed by a short behavioral note. The slight redundancy ('Dispatches test run' repeats the first sentence) prevents a perfect score, but overall it is concise and front-loaded with the core purpose.

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 5 parameters, no output schema, and only a readOnlyHint annotation, the description covers the essential behavioral aspects: dispatch, wait, timeout semantics, and resilience. It does not describe the success return format or polling behavior, but the schema provides parameter details. Overall, it is sufficiently complete for the tool's complexity.

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 all five parameters having descriptive text in the schema. The description itself does not add further parameter-level meaning beyond what is already in the schema. It mentions timeout behavior but does not tie it to specific parameters, 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.

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

The description clearly states the tool's function: dispatching tests and waiting for the exact run to become terminal. It uses a specific verb ('dispatch' + 'wait') and resource ('tests'), and distinguishes itself from run_tests by emphasizing the waiting behavior. The added note about no confirmation further clarifies the action.

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 this tool is for running tests and waiting for completion, but does not explicitly compare it to alternatives like run_tests. There is no direct 'when to use' or 'when not to use' guidance, though the wait semantics are clear. The absence of exclusions or alternative references makes the guidance only moderate.

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 mark the tool as destructive. The description adds specific behavioral context for save_copy (e.g., 'writes current dirty state to path as backup; active scene reference unchanged') and clarifies include_unsaved is always True. However, it does not explain side effects for destructive actions like discard or close beyond what the annotation states.

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 compact yet organized, listing actions as a shorthand and then explaining parameter requirements in a structured way. It efficiently packs essential details without unnecessary elaboration, though it reads as a dense run-on in places.

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

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

Given the tool has nine actions and overlaps with siblings like `set_active` and `scene_change_plan`, the description could be more complete. It covers parameter mapping well but does not describe return values for actions like `list`, nor does it explain when to use the scene tool vs. its siblings. The absence of an output schema increases the need for these details.

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 description adds meaningful parameter semantics that go beyond the schema. It explicitly ties each action to required parameters ('path required for open/save/open_additive/close/set_active/save_copy'), clarifies the 'scene' parameter for identifying multiple loaded scenes, and explains the `include_unsaved` behavior (always True for save_copy). This compensates for the 75% schema coverage.

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

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

The description clearly states 'Scene management' and enumerates nine specific actions (new, open, save, discard, open_additive, close, set_active, list, save_copy), making it easy to understand the tool's scope. It is less explicit in differentiating from the sibling `set_active` tool, which also handles scene activation, so it loses a point on full distinction.

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 provides per-action parameter requirements (e.g., 'path: required for open/save/open_additive/close/set_active/save_copy'), but it does not explain when to use this tool versus alternatives like `scene_change_plan` or `apply_scene_change`. There is no mention of exclusions, warnings, or alternative tool 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?

The description does not disclose any behavioral traits beyond the annotation readOnlyHint=false. It does not explain side effects, expected output, or the nature of the 'safe scene edit' guarantee. With only a one-sentence description, the burden of transparency is almost entirely unmet.

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 extremely short, but it is under-specified rather than concise. The '1.' appears to be a leftover from an incomplete numbered list, which is a structural flaw. It does not earn its place as a meaningful statement.

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

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

Given there is no output schema, minimal annotations, and a description that provides almost no context, the tool is severely under-described. A planning/pre-flight tool likely has complex behavior, but nothing explains what the plan entails, how it is returned, or what 'safe' means.

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?

There are zero parameters, so the baseline score of 4 applies. The description does not need to explain parameter details. However, it could have elaborated on what aspects of a scene edit are checked or planned, but that falls under other dimensions.

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 it is a 'Pre-flight + plan for safe scene edit', which gives a vague sense of purpose but lacks a specific verb or resource. The trailing '1.' suggests an incomplete list, adding confusion. It does not clearly distinguish from sibling tools like apply_scene_change or verify_after_change.

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

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

No guidance is provided on when to use this tool versus alternatives. The phrase 'pre-flight + plan' implies it might be used before edits, but there is no explicit context, exclusions, or mention of sibling tools.

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 description significantly extends beyond the readOnlyHint annotation by explaining behavior such as returning a file path by default, forcing a path with raw=True, generating Haiku text with describe, auto-setting camera from annotation_id, and the meaning of zoom/angles/supersample. It does not contradict the annotation and provides valuable operational context.

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 compact and front-loaded with the core action, then follows with a dense but organized reference of parameters. Every sentence contributes, though the line-packed formatting is somewhat cryptic; still, it's appropriately sized for a tool with 16 parameters.

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

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

Given the tool's complexity (16 params, no output schema), the description covers nearly all behavioral aspects: output modes, camera options, framing controls, highlight syntax, and annotation handling. Minor gaps exist (e.g., exact return format/path details), but the description is substantially complete for a tool of this scope.

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?

Although schema coverage is 100%, the description adds key semantic value by explaining syntactic shorthand (e.g., 'ex,ey,ez', '_=skip', 'paths[:#RRGGBB]'), the relationship between describe and raw, and how annotation_id auto-configures camera. These details are not in the schema and help an agent invoke parameters correctly.

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 'Capture screenshot (file path)'—a specific verb+resource pairing that clearly states the tool's purpose. It goes on to describe the two primary output modes (file path or Haiku description), which distinguishes it from all sibling tools that are unrelated to image capture.

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 on how to use the tool, including camera modes, angle presets, zoom semantics, and framing options. It doesn't explicitly name alternatives because no sibling tool serves a similar function, but the extensive parameter guidance makes its intended use evident.

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 annotation readOnlyHint=true already indicates a safe read operation, and the description adds behavioral details like 'root: scope search to subtree (path or None for whole scene)' and 'limit: max results (default 50; 0=unlimited)'. It does not discuss return format or error behavior, but the annotation lowers the bar and the added details are useful.

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 purpose, followed by a compact syntax line and then brief parameter explanations. Every sentence earns its place, with no fluff or redundancy, making it highly efficient.

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 search tool with no output schema, the description adequately documents the query syntax, all parameters, defaults, and special values (0=unlimited). It lacks explicit return-value details, but the read-only nature and clear invocation requirements make it sufficiently complete for an agent to use 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 description coverage is 100%, so the baseline is 3. The description essentially repeats the parameter semantics found in the schema, though it adds the shorthand syntax summary (e.g., 'tag=Tag', 'layer=N') and clarifies 'multi-scene only' for the scene filter, which is a slight enhancement.

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 'Search scene objects' with a specific verb and resource, making the core purpose obvious. However, it does not explicitly differentiate itself from sibling tools like get_hierarchy or inspect, 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.

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

The description implies usage through its query syntax and parameter explanations—use this when you need to find scene objects by name, component, tag, layer, or active state. It provides no explicit alternatives or when-not-to-use guidance, leaving the agent to infer context from the sibling list.

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 readOnlyHint=false and idempotentHint=true, covering the mutation and idempotency aspects. The description adds no additional behavioral context such as side effects on children, persistence, or error behavior, but given the annotations, the minimum baseline is met.

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 concise sentence, front-loads the core action, and contains no redundant or filler content. 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?

Given the tool's simplicity, the two clearly documented parameters, and the presence of behavioral annotations, the description is sufficiently complete for an AI agent to understand and invoke the tool correctly. No output schema or complex return value needs explanation.

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% and both parameters ('path', 'active') have clear descriptions. The tool description does not add extra parameter-level meaning beyond what the schema already provides, which fits the baseline for high coverage.

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

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

The description uses a specific verb ('Set') and clearly identifies the resource ('GameObject') and the operation scope (active/inactive). This unambiguously distinguishes it from sibling tools like set_property or set_parent, and directly names the state being modified.

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 provides no explicit guidance on when to use this tool versus alternatives, no prerequisites (e.g., valid scene path), and no exclusions. It only states what it does without contextualizing its place among the sibling tools.

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?

Beyond the annotations, the description discloses the behavioral impact of world_position_stays (preserving world vs. local transform) and the null-parent case, adding significant context. There is no contradiction with the idempotentHint or readOnlyHint 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, front-loaded with the primary action, and contains no redundant or filler text. Every phrase adds value.

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

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

With only three parameters, full schema coverage, and no output schema, the description combined with the schema leaves no significant ambiguity. It covers the main behavioral variations and is appropriate for the tool's complexity.

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 already provides complete descriptions for all three parameters (100% coverage), and the tool description largely restates these definitions without adding new details or edge-case guidance. This earns the baseline score for high schema coverage.

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

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

The description opens with the specific verb 'Reparent' and the resource 'GameObject', clearly stating what the tool does. It also clarifies the null-parent behavior, distinguishing it from sibling tools like set_active or set_property.

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 for when to use the tool (any reparenting operation) and explains the effect of the key parameters. However, it does not explicitly mention alternatives or when not to use it, stopping short of the highest mark.

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 description adds behavioral context beyond annotations: it notes the Edit Mode limitation, explains dry_run as a safe preview, and details how ref_component_type resolves plain scene paths. Annotations already indicate idempotency and non-read-only, so the description supplements without contradicting them.

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 dense but purposeful. Every sentence covers a distinct concept (mode, find_type, rename alternative, value formats, dry_run, ref_component_type) with no filler. A minor typo ('BoxClider') does not affect understandability.

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

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

Given the tool's complexity (7 params, no output schema), the description covers the key operational modes, bulk behavior, reference format details, and safety preview. Combined with the strong schema descriptions, it gives the agent enough to select and invoke 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 description coverage is high (86%), and the description further clarifies find_type for bulk operations, dry_run's preview effect, ref_component_type (which has no schema description), and the complete ObjectReference value format. This goes beyond the structured fields.

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 sets a component property, with a specific verb and resource. It distinguishes itself from siblings by explicitly mentioning Edit Mode/SerializedObject and contrasting with Play Mode tools like invoke_method/execute_code, plus rename_object() for renames.

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 gives explicit usage context: 'Edit Mode, SerializedObject' and directly names alternative tools for Play Mode ('use invoke_method or execute_code') and for renames ('use rename_object()'). This makes the when-to-use boundary crisp.

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 only state readOnlyHint=false, which aligns with the mutating refresh/bump behavior. The description goes beyond annotations by specifying the return contract ('sync clean' / compile errors / timeout message) and the ordering/atomicity of bump before sync.

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 compact and well-structured: a one-sentence overview, then bullet-like usage notes, then return outcomes. Every sentence earns its place with no filler or repetition.

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?

Despite having no output schema, the description states the three possible return outcomes. It also covers optional behavior, ordering, and atomicity. For a tool with three optional parameters, this is sufficient 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.

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

Schema coverage is low (33%), and the description compensates by explaining resolve and bump semantics, including their relationship. It does not add detail for timeout, but the schema already describes that parameter; overall the description adds meaningful meaning beyond the 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+resource construction: 'Unified Unity reload: trigger Refresh (+ optional Resolve)' and clearly states the tool's purpose. It distinguishes itself by presenting a consolidated sync workflow, unlike sibling tools that target narrower actions like await_compile or reconnect_unity.

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 explicit situational guidance: 'resolve=True: call Client.Resolve() first (use after package.json change)' and explains that bump implies resolve. It does not name alternative sibling tools or state exclusions, but it provides clear context for when to use key options.

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 description goes beyond the readOnlyHint annotation by detailing the return format ([ERROR]/[MISSING], summary line), explaining the effect of verbose and ignore_optional, and noting token savings. This provides substantial behavioral context.

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 compact and front-loaded: it states the core function first, then the output format, then practical parameter advice. Every sentence adds value.

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

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

Given the tool's moderate complexity, the description covers the main purpose, output format, and parameter behavior. No output schema exists, but the description's mention of return format fills that gap. Combined with the readOnly annotation, the description is sufficient for correct usage.

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 only describes path and depth, leaving verbose and ignore_optional undocumented. The description adds meaningful explanations for these parameters and offers depth usage guidance, compensating for the 50% schema coverage.

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

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

The description clearly states the tool's function: validating ObjectReference fields under a path recursively. It uses a specific verb and resource, and differentiates from siblings by focusing on ObjectReference validation and providing output format.

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 provides parameter-specific usage guidance (depth recommendations, verbose usage, ignore_optional behavior). However, it does not explicitly mention alternatives or when not to use this tool, so it stops 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.

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

The annotations only include readOnlyHint=false, providing minimal safety context. The description adds that gates are additive and only enabled ones run, but does not disclose what running a gate entails, potential side effects, or what happens on failure. Given the description carries the burden, this is insufficient behavioral transparency.

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 extremely short, which is generally positive, but the second sentence ends abruptly with '1.' indicating a truncated list. This structural flaw makes the description incomplete and confusing, violating the principle that every sentence should be complete and useful.

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

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

With no parameters, no output schema, and minimal annotations, the description must carry the full explanatory burden. It fails to specify what the enabled gates are, how they are enabled, what verification means in practice, or what the tool returns. The truncated list and vague 'gate' terminology leave the tool under-specified for an agent to use 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?

There are zero parameters, so the baseline is 4. The schema already has an empty properties object, and the description does not need to explain any parameter semantics. No additional parameter description is necessary.

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

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

The description identifies the tool as a 'Single verification gate after code/scene changes,' which names the action (verification) and the context (after changes). However, the term 'gate' is vague, and the trailing '1.' suggests the description is truncated, so the full scope of what it verifies is unclear. It does not clearly differentiate from sibling tools like compile_preflight or run_tests.

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 provides a clear temporal usage context ('after code/scene changes') and states that gates are additive and only enabled ones run. However, it does not explain when to choose this tool over specific sibling tools, nor does it mention cases where other verification or preflight tools 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.