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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the basic safety profile is covered. The description adds placement behavior by saying the block can be chained after afterId, but it does not disclose behavior around dryRun, confirm, invalid opcodes, or whether the block is inserted at a default position.

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 action in the first phrase, adds the key placement detail, then gives a practical tip. Every sentence earns its place 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?

Given 10 parameters, nested objects, no output schema, and zero parameter documentation, a two-clause description is not enough for an agent to call the tool confidently. It covers the core purpose and afterId, but leaves most of the input surface undocumented, so completeness is low.

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

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

Schema description coverage is 0%, so the description must compensate for 10 parameters. It explains a meaningful detail for afterId and hints that opcode matters via the describe_opcode tip, but x, y, path, target, fields, params, dryRun, and confirm remain entirely unexplained.

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

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

The description states a specific action ('Add') on a specific resource ('a single block'), and the qualifier 'single' plus 'optionally chained after afterId' distinguishes it from related tools like add_script or move_block. It is immediately clear what this tool does and what its unique scope is.

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 useful workflow hint ('Tip: describe_opcode first'), which implies the agent should validate opcodes before calling. However, it does not explicitly say when to prefer this over sibling tools like add_script or move_block, nor does it state exclusions or preconditions.

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 the tool is idempotent and non-destructive, so the safety profile is covered. The description adds useful behavioral detail: it handles block connections (next/parent/shadows) and requires the first entry to be a hat. No contradictions with annotations. However, it does not disclose side effects like whether existing scripts are replaced or if target must be valid.

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 that delivers the core purpose immediately and adds a key constraint. No filler words – every clause contributes 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 complexity (7 parameters, nested block schema, no output schema), the description is insufficient. It fails to explain essential context like what 'file' refers to, the role of target/path, what dryRun and confirm do, and any effect on existing scripts. An agent cannot fully execute this tool correctly from the description alone.

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 0% description coverage, placing the full burden on the description to explain parameters. The description only hints at the block structure ('Handles next/parent/shadows + SUBSTACK'), which relates to the nested block schema but not to the top-level parameters (blocks, x, y, path, dryRun, target, confirm). No meaning is added for these, leaving agents to guess their roles.

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: 'Put a whole stack of blocks at once' – distinguishing it from the sibling add_block which likely adds a single block. It also adds a specific constraint ('First entry should be a hat'), which clarifies scope. However, it does not explicitly name add_block as the alternative, so differentiation is implied rather than direct.

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 like add_block or app_put_script. The description does not mention any prerequisites (e.g., a target must exist), exclusions, or scenarios where this tool is preferred. An agent would need to infer from the 'whole stack' wording that it is for multi-block scripts.

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 indicate readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the tool is clearly a mutation that may not be idempotent and is not destructive in the usual sense. The description merely says 'add,' which adds no additional behavioral detail, such as side effects on existing sprites, required project state, or the effect of the confirm parameter.

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 clear sentence with no wasted words, which is concise. However, it is extremely under-specified, lacking any elaboration on the tool's operation. While it is front-loaded with the core action, it doesn't earn its place by adding meaningful information beyond the tool name.

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 3 parameters, no required fields, no output schema, and no descriptions for parameters, the tool is far from complete. The description does not explain the 'path' parameter, the purpose of 'confirm,' or how adding a sprite differs from renaming one, leaving an agent with insufficient information to invoke it correctly.

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

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

Schema description coverage is 0%, and the description does not mention any parameters (name, path, confirm). It provides no meaning beyond the parameter names themselves, leaving the agent to guess what 'path' refers to or what 'confirm' controls. This is a serious gap given the zero coverage.

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

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

The description states a clear action ('Add') and a specific object ('sprite target'), which distinguishes it from sibling tools like list_targets and rename_target. It is not a tautology and conveys the primary purpose effectively, though it lacks context on what a sprite target is.

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 guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., a project must be open) or contrast with rename_target, list_targets, or other related tools. The usage context is entirely 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?

The description only states the basic action. It does not disclose whether an existing variable is overwritten, whether confirm is required, whether the operation is reversible, or what side effects may occur. The annotations indicate mutation, but the description adds little beyond that.

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, front-loaded sentence with no filler. However, it is so sparse that it is more under-specified than genuinely concise, providing only the bare minimum.

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

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

With five parameters, no output schema, and no parameter documentation, the description is not sufficient for an agent to reliably call this tool. It does not clarify what a valid target is, how value/path interact, or what confirm does.

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

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

Schema description coverage is 0%, and the description provides no explanation of name, path, value, target, or confirm. Since the description must compensate for the missing schema descriptions but does not, parameter semantics are effectively unaddressed.

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

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

The description names a specific verb ('Add'), a resource ('global variable'), and a destination ('a target'). This is clear enough to understand the core action, though it does not explicitly differentiate from sibling tools like app_set_var or add_script.

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 guidance on when to use this tool versus alternatives, nor any mention of prerequisites, exclusions, or conditions under which it should not be used. Given many sibling tools, this is a noticeable gap.

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 and idempotentHint, covering the safety profile. The description adds that this is a live read via device.getCode(), which gives some insight into the operation's nature, but it does not discuss potential device availability or failure behavior.

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 with no filler. It front-loads the key qualifier 'LIVE' and immediately states the operation and source.

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 parameterless read-only tool with no output schema, the description provides enough context: it states the output type (transpiled Python/ArduinoC) and the method (device.getCode()). It is missing only minor details like error/availability 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?

The tool has zero parameters, and the schema coverage is 100%, so the schema fully describes the input space. The description has no parameter information to add, which is acceptable and matches the baseline for parameterless tools.

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

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

The description names a specific verb and resource: getting transpiled Python/ArduinoC code via device.getCode(). It clearly explains what the tool does, though it does not explicitly contrast itself with sibling tools like export_code.

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 retrieving live transpiled code, partly through the 'LIVE' prefix and 'in the app' phrasing. However, it does not explicitly state when to prefer this over 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating a safe, non-destructive, idempotent read. The description adds a useful behavioral cue with 'LIVE:', which implies the tool reads the current value at call time, possibly reflecting immediate state changes. This adds context beyond the annotations.

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

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

The description is extremely concise at one sentence and front-loads the key information ('LIVE: read a global variable'). It is appropriately sized for a tool with a single parameter. However, it could have added a brief note on parameter usage without being verbose.

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, no nested objects), and the description combined with annotations covers the basic safety profile. However, it does not explain what the return value is or what 'LIVE' means in terms of consistency or caching. Without an output schema, the description should have clarified the return format, but the simplicity keeps it at a minimum viable level.

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

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

The schema has only one parameter 'name' with no description, and the description does not explain what 'name' refers to (e.g., variable name format, case sensitivity, or how to find valid names). Since schema coverage is 0%, the description fails to compensate for this lack of detail, though the parameter name is self-explanatory to some degree.

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

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

The description states a specific verb ('read') and resource ('global variable from the app workspace'), making the purpose clear. It does not explicitly distinguish from siblings like app_set_var or app_get_code, but the verb 'read' and the resource 'variable' are unambiguous enough to differentiate it from most siblings.

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

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

The description implies a read operation and provides no explicit when-to-use guidance. It does not mention alternatives like app_get_code or app_sensor_snapshot, nor does it state when not to use it. The context is clear for a simple read, but the lack of any mention of when to prefer this over siblings leaves some ambiguity.

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=false, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds that this is a combination of mutation (inject and run) and a read (variable retrieval), which is consistent. It does not contradict annotations and provides useful context about the multi-step nature.

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

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

The description is a single, dense sentence that front-loads the core purpose and avoids fluff. It is concise and immediately conveys the tool's unique value proposition without unnecessary detail.

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 six parameters, a recursive blocks schema, and no output schema, the description is insufficient. It does not mention the return value (presumably the variable value), nor does it clarify the meaning of positional parameters like target, x, and y. An agent would need to inspect the schema and likely infer usage from sibling tools, which is not ideal for a tool that combines multiple operations.

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 only 17%, with only readVar described. The tool description mentions 'inject a script, run its hat, read back a variable', which loosely maps to blocks, hatOpcode, and readVar, but does not explain parameters like x, y, or target. The description fails to compensate for the low schema coverage, leaving these parameters underspecified.

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

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

The description states a specific composite action: inject a script, run its hat, and read back a variable, all in one call. It uses the analogy 'like upload-and-monitor' and explicitly mentions the three sub-steps, clearly distinguishing it from sibling tools like app_put_script, app_run_hat, and app_get_var.

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

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

The phrase 'LIVE combo' and 'in one call' conveys that this is a convenience wrapper for combined operations. It implies an agent should use this tool when it needs the full pipeline, but it does not explicitly state when to use alternatives instead, though the sibling names make that inferable.

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, readOnlyHint=false, destructiveHint=false. The description adds the fallback behavior ('Falls back to file hint if offline') and the requirement that the app must be OPEN. These are valuable behavioral traits not present in the annotations. No contradiction with annotations.

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

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

The description is a single sentence with no wasted words. It front-loads 'LIVE:' and immediately conveys the core purpose. It is appropriately concise, though brevity trades off against completeness.

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

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

This tool has a complex nested schema (blocks array with opcode, fields, params, substacks) and no output schema. The description is too terse to guide an agent on how to construct valid input. It does not explain 'file hint', the bridge, or the expected structure of 'blocks'. Given the schema complexity, more context is needed.

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

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

Schema description coverage is 0%, so the description carries the full burden for parameter explanation. It does not mention any of the four parameters (x, y, blocks, target) or how to structure the blocks array, which has a recursive schema. The description adds no meaning beyond what the schema shows, which is insufficient given the zero coverage.

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

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

The description states a specific action ('put a script'), the target ('OPEN mBlock app'), and the mechanism ('via the bridge'). It also mentions a fallback, distinguishing it from siblings like app_put_and_run (which would add 'and run') and add_script (which targets a project rather than the live app). The 'LIVE:' prefix clearly sets it apart.

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 when the mBlock app is open and live, and mentions an offline fallback. However, it does not explicitly name alternative tools (e.g., app_put_and_run for putting and running, or add_script for project scripts) or state when NOT to use this tool. The context is clear but not exhaustive.

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=false (so it mutates), idempotentHint=true, and destructiveHint=false. The description adds the 'LIVE' qualifier and the internal method, which gives a hint of real-time execution, but it does not explain side effects or what 'run a hat block' implies (e.g., triggers the associated script). With annotations covering safety, a 3 is fair.

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 short sentence with no filler. It front-loads the key action and includes the method name. Very 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 simple one-parameter tool, the description states the core function, but it lacks guidance on when to use it versus similar tools and does not mention any required preconditions. Given the large sibling list, more differentiation would be helpful, so a 3 is suitable.

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 100% of the parameters with a description and example for 'opcode'. The tool description adds no additional semantics for the parameter, so it relies entirely on the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('run') and resource ('hat block'), and names the underlying API method (app.workspace.runBlocks). It is clear enough to identify the action, but does not explicitly differentiate from sibling tools like app_put_and_run or add_script, so it lacks a distinguishing edge.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., app must be open, a hat block must exist) nor contrast with tools that run full scripts or add blocks. An agent would have to infer usage from the name alone.

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 'non-blocking', 'pushes a state request', and 'returns latest bridge push + live var read', which gives some context beyond the readOnly/idempotent annotations. Yet it does not explain timeout behavior, freshness guarantees, or what 'bridge push' exactly entails.

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

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

The description is short and front-loaded with the key signal ('LIVE: non-blocking'), but the second sentence partially repeats the first and adds only moderate value. It is nearly tight, with minor redundancy.

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

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

For a simple read tool with rich annotations, the description covers the gist and main return content. However, it leaves the agent guessing about timeoutMs semantics, what 'bridge push' refers to, and how 'name' omitting changes behavior beyond the schema line.

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 does not add any meaning to the parameters. The schema describes 'name' but not 'timeoutMs', leaving 50% coverage; the description does nothing to compensate, so an agent cannot tell what a timeout actually controls.

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

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

The description clearly states a live, non-blocking sensor/variable read and explicitly mentions pushing a state request and returning the latest bridge state. However, it does not distinguish itself from the sibling app_get_var or app_status, so an agent must inspect schemas to choose the right read tool.

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 guidance on when to use this tool versus alternatives like app_get_var or app_status. The 'LIVE' qualifier implies it is for fresh snapshots, but no exclusions or alternative conditions are stated.

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

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

Annotations already provide readOnlyHint=false, idempotentHint=true, and destructiveHint=falseikuha. The description adds 'LIVE' and the workspace scope, but it does not disclose important behaviors such as overwriting an existing variable, whether the variable must already exist, whether it is created if absent, or what the tool returns. No annotation contradiction is present.

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 short sentence that is front-loaded and contains no filler. The 'LIVE:' prefix is somewhat unexplained and may not contribute meaningful structure, but overall the entry is appropriately compact.

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

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

For a simple two-parameter setter, the description gives the basic action, but with no output schema and no usage guidance, an agent lacks context about return values, whether variable creation is implicit, and how this differs from add_variable. The available annotations do not cover these gaps.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter detailsci. It does not define 'name' or 'value' beyond their obvious names, nor does it clarify value types, coercion behavior, or how 'global' affects interpretation of the name 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 uses the verb 'set' with the object 'a global variable in the app workspace', which clearly indicates a value-assignment operation. It is distinguishable from the sibling app_get_var (read), but it does not explicitly distinguish itself from add_variable, which could imply creating a variable.

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 guidance about when to use this tool versus add_variable or app_get_var. The 'LIVE:' prefix hints at runtime context, but there are no explicit conditions, exclusions, or alternatives mentioned.

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 this as read-only, idempotent, and non-destructive. The description adds value by specifying the precondition (open app + drag in mblock-bridge.mext) and clarifying what 'connected' means, going beyond the raw 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?

A single, compact sentence that front-loads the purpose and includes the necessary setup hint. No wasted 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 parameterless status check, the description provides enough context to call it correctly: what it checks and how to ensure the prerequisite. The annotations carry the safety profile, and there is no output schema required. Nothing important 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?

There are zero parameters, so the schema fully covers the input side. The description adds contextual meaning about the connection check, which is appropriate since there is nothing to elaborate on. The baseline for zero parameters is 4.

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 verb 'Check' and the resource 'mBlock 5 app bridge', and clarifies what 'connected' means by referencing the setup steps. It distinguishes this status-check tool from the many app_* operation tools in the sibling 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?

The description implies that the bridge must be connected for the tool to work, and gives instructions to achieve that, but it does not explicitly say when to use this tool versus alternatives (e.g., before calling app_put_script). The guidance is implicit 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?

Annotations already indicate idempotentHint=true and destructiveHint=false. The description adds the file types and the manual drag step, but does not disclose details like overwriting behavior or any side effects. Since annotations cover the safety profile, the description adds only modest behavioral context beyond them.

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

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

The description is a single, efficient sentence that front-loads the action and includes the key file types and purpose. 'Run once' is a useful, non-redundant addition. There is no wasted 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 simple tool with one optional parameter, no output schema, and annotations covering idempotency and non-destructiveness, the description provides sufficient information for an agent to decide when to call it and what it will do. The purpose and usage hint are clear, 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 sole parameter (folder) is fully described in the schema (100% coverage) with a default value. The tool description does not mention the parameter at all, so it adds no semantic value beyond the schema, matching the baseline of 3 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 clearly states the action (Write), the resource (mBlock-app bridge files), and the specific file types (.mext + setup JS). It also explains the purpose ('so you can drag the .mext into the app'), making it unambiguous and distinct from siblings like import_mext_catalog or app_put_script.

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 usage context ('Run once' and 'so you can drag the .mext into the app'), indicating it is a one-time setup step. However, it does not explicitly mention alternatives or when not to use it, so it lacks the exclusions that would merit a 5.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations: deletion cascades to the next-chain by default, and confirmation is mandatory. This gives an agent a clearer picture of the operation's side effects.

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

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

One short sentence delivers the core action, the default cascading behavior, and the required confirmation flag. Every element earns its place and is front-loaded with the primary verb and object.

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 destructive 5-parameter tool with no output schema, the description is minimally adequate: it names the deletion scope and the confirmation requirement. However, it omits the role of path and target, the effect of setting deleteChildren=false, and what happens after deletion, leaving gaps an agent may need to resolve.

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

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

Schema description coverage is 0%, so the description must compensate, but it only partially addresses parameters. It clarifies confirm (must be true) and deleteChildren indirectly via 'next-chain by default', but leaves path, target, and blockId unexplained despite the schema offering no descriptions for them.

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 a specific verb and resource: 'Delete a block' and adds the key scoping detail that the next-chain is deleted by default. This distinguishes it from sibling tools like add_block, move_block, and set_block_field without requiring schema inspection.

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

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

The description makes the confirmation prerequisite explicit ('Requires confirm:true') and implies the destructive use case, but it never states when to prefer this over alternatives or when not to use it. It provides enough context to understand the operation, but no exclusion or comparison guidance.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds context beyond that: that it returns the inputs/fields/example for an opcode and is a prerequisite for add_block. No contradiction with annotations.

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

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

The description is brief and front-loaded with the tool's function and primary usage. It has no wasted words, though the first sentence is a fragment rather than a complete, polished phrase.

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

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

For a simple one-parameter, read-only tool with no output schema, the description is largely sufficient. It tells the agent what the tool does, what it returns, and when to use it. The main gap is the lack of guidance on valid opcode values, but that is somewhat covered by sibling tools like list_opcodes.

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 has no description for the single 'opcode' parameter and schema coverage is 0%, so the description carries the burden. It only says 'for one opcode' and does not explain valid values, format, or where to obtain an opcode identifier. This is minimal compensation for the missing schema documentation.

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 resource ('one opcode') and the kind of information provided ('Inputs/fields/example'), which is clear enough to distinguish from list_opcodes and add_block. It is not a full sentence, but the meaning 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 explicitly says to run this tool before add_block to get parameters right. It provides clear usage context, though it does not name alternatives or state 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 readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds behavioral context by enumerating the specific areas checked factually beyond what annotations express, and nothing contradicts the annotations.

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

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

A single, focused sentence that leads with the core purpose and immediately gives actionable usage guidance. Every phrase earns its place, and there is no filler or repetition of schema content.

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 diagnostic with rich safety annotations, the description is nearly complete: it defines the target scope and the recommended invocation condition. It does not describe the output format, but given the tool's simplicity and lack of output schema, this is a minor gap rather than a blocking omission.

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)Skip; schema coverage is 100% for an empty schemaches, so the description carries no parameter burden. The description adds value by defining the tool's scope rather than repeating parameter details, matching the baseline for a parameterless tool.

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 diagnostic verb ('Health check') with a defined resource ('whole mBlock setup') and lists the concrete components checked: server, bridge app link, projects folder, bridge file. This clearly distinguishes it from sibling tools like project-validate or app_status, which are narrower in 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 gives explicit guidance on when to run this tool: 'Run first when anything behaves oddly.' It does not list exclusions or alternative tools, but the condition is clear enough for an agent to select it as the first diagnostic step.

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 and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context about the output being human-readable and covering every script, but it does not go deeper, such as potential size or performance implications.

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 clear sentence with no filler. The parenthetical analogy is compact, though slightly cryptic, so it is concise without being perfectly transparent.

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 parameter documentation and no output schema, the description is not complete enough for reliable invocation when customization is needed. The annotation set covers safety, and the general purpose is clear, but the undefined parameters leave a significant practical 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?

Schema coverage is 0% and neither 'path' nor 'target' is explained in the description. An agent has no way to know what these parameters mean, what values are valid, or how they affect the export. This is a major gap.

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

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

The description names a specific verb ('Export') and a clear resource ('a human-readable listing of every script in the project'). It also distinguishes itself from siblings like get_script by emphasizing 'every script' and the review-oriented 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 phrase 'review before running' clearly establishes the intended use case: inspecting all scripts before execution. It does not explicitly list alternatives or exclusions, but the context is unambiguous enough for routing.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds that the result includes the block's full JSON plus its catalog definition, which provides useful return-content context without contradicting the annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the core meaning, and the return payload scope is conveyed efficiently.

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

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

For a tool with three parameters, no output schema, and zero parameter descriptions, this description is too thin to be fully actionable. Annotations cover safety, but the agent still lacks understanding of path/target and how they affect the retrieved block.

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 and no parameter descriptions in the schema, the description needed to explain the parameters. It only implicitly connects 'one block' to blockId, leaving path and target completely unexplained, so the agent gets minimal help invoking the tool 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 states a specific action (get), a resource (block), and the scope (one block), making the core purpose clear. It does not explicitly name or contrast sibling tools, but 'one block' helps distinguish it from list_blocks and other block-related operations.

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 such as list_blocks or get_script. The description implies it is for retrieving a single block's full data, but it does not state conditions, exclusions, or preferred 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?

Annotations already declare the tool as read-only, idempotent, and non-destructive, so the description is not required to repeat that. It adds the specific behavior of following the next-chain from a hat block, which is useful context, but it omits details like error handling, return format for missing chains, or whether it returns blocks or IDs. This is acceptable given the annotations cover safety, but the description adds limited extra behavioral depth.

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, focused sentence that conveys the essential purpose with no filler or redundancy. It is efficiently front-loaded with the action and resource, earning full marks for conciseness.

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

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

For a tool with three parameters (one required) and no output schema, the description leaves significant gaps: it does not explain 'path' or 'target', nor describe the return structure (e.g., list of block IDs vs. block objects). An agent would struggle to correctly invoke this tool without additional information.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It only implicitly clarifies hatId (the 'hat block'), and gives no meaning for 'path' or 'target'. The agent has no way to infer what these strings represent or how they affect the call, making parameter usage opaque.

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 a specific action ('Follow the next-chain from a hat block') and outcome ('return the ordered script'). It distinguishes itself from siblings like get_block (which returns a single block) and add_script (which creates scripts) by focusing on traversal and ordering.

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 such as get_block or app_put_script. The description does not mention conditions, prerequisites (e.g., needing a valid hatId), or cases where a different tool would be more appropriate.

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

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

Annotations already indicate the operation is idempotent and non-destructive. The description adds the outcome that opcodes become known, but it does not disclose whether the import merges with or replaces existing opcodes, whether an open project is required, or how the state is persisted. Disclosure is partial.

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

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

The description is a single sentence with no filler. The verb and resource are front-loaded, and the parenthetical outcome earns its place by explaining the practical benefit.

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

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

For a simple one-parameter tool with annotations and no output schema, the description covers the core purpose and expected effect. However, it omits operational details such as whether the import modifies a project, how it interacts with existing opcodes, and whether any setup is required, leaving it adequate but not fully complete.

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

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

Schema coverage is 0%, and the description never explicitly documents the 'path' parameter. It implies the path points to a community .mext block catalog JSON, which adds meaning beyond the bare string name, but it leaves path format, scope, and file requirements unspecified.

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

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

The description states a specific action, importing a community .mext block catalog JSON, and a clear outcome: its opcodes become known and unknown warnings stop. This distinguishes it from sibling inspection tools like list_opcodes and describe_opcode, and no other sibling imports catalogs.

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 this tool: when dealing with community .mext content and unknown opcode warnings. It does not explicitly name alternatives or exclusions, but the triggering condition is implicit in 'no more unknown warnings.'

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds one behavioral trait—pagination—which is useful, but it does not disclose default limit/offset behavior, ordering, or what happens when required parameters are omitted.

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 front-loaded sentence with no filler. Every word contributes: the action, the scope, and the pagination behavior. It is as concise as possible while carrying meaningful information.

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

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

For a tool with 5 parameters, no output schema, and sparse schema descriptions, this description is too thin. It does not explain return values, parameter relationships, or how to specify the target. The pagination mention helps, but the agent would still need to inspect schema and infer several details to call the tool correctly.

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

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

Schema description coverage is only 20% (only 'category' is documented), and the description does not compensate. It mentions 'on a target' and 'paginated', giving some hint about target and pagination, but it does not explain the roles of 'path' and 'target', nor the semantics of limit and offset.

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

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

The description states a specific action and resource: 'List blocks' and scopes it to 'a target'. It distinguishes the tool from get_block (list vs. single fetch) and is more specific than a bare tautology. However, it does not clarify what a 'block' is in this domain, leaving some ambiguity.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like get_block or list_opcodes. It implies a list-all use case, but does not state exclusions, prerequisites, or when a sibling would be more appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description itself adds no behavioral context such as filtering, limits, or return shape, but for a simple non-mutating list tool the annotation coverage is adequate.

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 front-loaded sentence with no filler. However, the parenthetical 'like lib-examples: starter art inventory' is vague and may confuse rather than help, preventing a perfect score.

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 two parameters, zero schema descriptions, and no output schema, the description leaves important details unstated: what 'path' means, how 'target' is formatted, and what the returned list looks like. This is too incomplete for confident 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 description coverage is 0%, so the description must compensate. It only clarifies 'target' and gives a cryptic 'like lib-examples: starter art inventory' example; the 'path' parameter is never explained. This is insufficient for a tool with minimal schema support.

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

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

The description names a specific verb ('List') and resource ('costumes/backdrops') scoped to a target. This distinguishes it from sibling tools like list_sounds and list_blocks, though the combined 'costumes/backdrops' phrasing and the parenthetical example are slightly imprecise.

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 guidance about when to use this tool versus alternatives such as list_sounds or list_blocks. The only implied context comes from the tool's name and resource type; no exclusions or explicit conditions 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds only the enumeration of device profiles and no additional behavioral details such as return formatting or ordering. There is no contradiction between the description and the annotations.

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

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

The description is a single tight phrase with no filler or redundant material. The core subject 'Supported device profiles' is front-loaded, followed immediately by the concrete list of values. Every word earns its place.

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

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

For a zero-parameter, read-only tool with no output schema, the description is nearly complete: it tells the agent exactly what the tool relates to and enumerates the relevant device profiles. The main gap is that it does not explicitly state that these profiles are the return value, but the tool name and annotations make this sufficiently clear.

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

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

The tool has zero parameters and 100% schema description coverage, so there is no parameter ambiguity to resolve. The description contributes useful domain vocabulary by listing the possible device profile values, which helps the agent understand the tool's domain even though no parameters are required.

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 resource (supported device profiles) and gives the exact set of values: sprite, mbot, cyberpi, arduino_uno, stage. It lacks an explicit verb, relying on the tool name 'list_devices' to convey the action, but the purpose is nevertheless clear. It does not explicitly differentiate itself from sibling list tools like list_targets or list_blocks, though the specific domain makes confusion unlikely.

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 call this tool rather than a sibling such as list_targets or list_blocks. There are no stated prerequisites, exclusions, or alternative selection criteria. For a zero-parameter read-only list tool the omission is not critical, but the description still provides no 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?

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, so the read-only safety profile is covered. The description adds the scope (core + imported MEXt) and searchable nature, which is useful context, but does not go beyond a basic description of behavior or include any caveats like pagination. This is adequate but not rich.

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

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

The description is a single sentence that front-loads the primary verb ('Searchable') and then provides the essential scope and filters with no filler or redundant text.

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 read-only, idempotent, simple list-like tool with optional parameters and no output schema, the description packs scope (core + imported .mext) and the two filters, which is enough for an agent to invoke it correctly. It does not describe output format or pagination, but the tool category (a searchable catalog) makes those gaps low-risk.

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 explains the `device` parameter values, while `query` has no explanation. The description says the tool is 'Filter by device and query', giving `query` some semantic role (a search term), but it does not explain match behavior (e.g., substring, exact, case-sensitivity) or further clarify `device` beyond the schema. Since schema coverage is only 50%, the description only partially compensates for the undocumented query 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 says 'Searchable block catalog (core + imported .mext)' and 'Filter by device and query', identifying a specific resource and action as well as scope. It is distinguishable from siblings like list_blocks by the explicit 'core + imported .mext' boundary, but it doesn't name or refer to any specific 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?

The description gives a clear use case: browsing a block catalog with filters for device and query. It does not, however, provide explicit when-to-use versus when-not-to-use guidance or point to alternative tools such as list_blocks or describe_opcode. The usage is implied rather than defined.

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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is already known. The description adds no behavioral context beyond that: it does not explain what a 'sound' is in this domain, whether the target must be valid, or any potential errors. It simply restates the operation without enriching the agent's understanding of side effects or requirements.

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, but it is under-specified rather than efficiently worded. It is a single simple sentence, which is acceptable for brevity, but the lack of any useful content means the structure does not earn its place; it provides no actionable information beyond the name.

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 absence of an output schema, the description should explain what the returned list of sounds looks like, but it does not. It also fails to clarify the required parameters, despite the tool having two parameters. With no annotations on parameters and a generic description, the tool is incomplete for an agent to call 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?

Parameter schema coverage is 0%, meaning the schema provides no descriptions for 'path' and 'target'. The tool description only mentions 'a target' but does not explain the 'path' parameter at all, nor the relationship between them. With zero coverage, the description fails to compensate, leaving both parameters semantically opaque.

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 'List sounds of a target' is a bare restatement of the tool name, providing no additional detail on what 'sounds' or 'target' refer to. It does not distinguish this tool from siblings like 'list_costumes' or 'list_blocks', all of which share the same pattern. The verb 'list' and resource 'sounds of a target' are minimal, but the lack of any specifics about the context makes it 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?

The description gives no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as needing a target opened, or how it relates to sibling tools like 'list_costumes' or 'get_script'. There is no explicit 'when not to use' or alternative routing, leaving the agent to infer usage based on the name alone.

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 and idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the specific resource types (Stage/sprites/devices) but does not disclose return format, ordering, or any limitations. This is a slight addition beyond annotations, so a 3 is appropriate.

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

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

A single concise sentence with no wasted words. The core action is front-loaded, and the parameter context is appropriately relegated to the schema. Perfectly 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 simple listing tool with one parameter fully documented in the schema and annotations covering safety, the description provides enough to call it correctly. The absence of output schema is compensated by the simple nature of the listing, though it would benefit from a note on what the returned list contains. Overall, adequately complete.

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

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

Schema coverage is 100% with a clear description for 'path' (Path to .mblock, omit if project-attach set). The tool description does not add any extra meaning to the parameter beyond what the schema already provides. Baseline 3 applies since the schema carries the full weight.

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 verb 'List' and the resource 'Stage/sprites/devices in a project'. It is specific enough to indicate what the tool returns. However, it does not explicitly differentiate from sibling 'list_devices' which might be a subset, so it loses a point for sibling 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?

No guidance on when to use this tool versus alternatives (e.g., 'list_devices', 'list_blocks'). The parameter note about 'omit if project-attach set' hints at a prerequisite but does not explain when to choose this tool over others. No exclusions or alternate routing 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?

Annotations already indicate readOnlyHint=false (so mutation) and destructiveHint=false (non-destructive), which the description correctly aligns with (it implies a move, not a delete). The description adds the 'top-level' constraintiative context, which is valuable)Skip providing more details on what happens to the block (e.g., whether it snaps to grid) or if it requires the block to be unattached.

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

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

One short sentence with no fluffholidays. It is front-loaded with the action. However, it is possibly too terse given the number of undocumented 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?

The tool has six parameters, three required, and no output schema, so the description needs to cover more. It does not explain the role of 'path', 'target', 'confirm', or any side effects. For a mutation tool, this is incomplete.

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

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

Schema description coverage is 0%, so the description must explain the parameters, but it only mentions 'x/y' which are self-explanatory. The 'path', 'target', and 'confirm' parameters are not described anywhere, and without schema descriptions, the agent cannot infer their purpose. This is a significant gap.

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

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

The description states a clear action ('Move a top-level block') and a specific operation (to x/y coordinates). It is distinct enough from siblings like 'set_block_field' or 'delete_block', though it doesn't name any sibling explicitly.

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 on when to use this tool versus alternatives. It doesn't mention if this is for visual positioning only or if it also updates the underlying script, and doesn't explain how it differs from 'set_block_field' or other mutation tools. The 'top-level block' qualifier hints at a constraint, but there is no clear context.

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

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

Annotations already establish that the tool is non-read-only, idempotent, and non-destructive. The description adds behavioral value by specifying exactly which project files get bundled into the archive. There is no contradiction with the annotations, and the operation's non-destructive nature is consistent with the description.

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 that front-loads the action verb, names the resource, lists the archive contents, and states the purpose. Every word earns its place, with no redundancy or 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 simple two-parameter archive tool with complete schema coverage and safety-relevant annotations, the description is sufficient for correct invocation. Path requirements, optional output default, and the tool's safety profile are all covered by the schema and annotations, so no essential information is missing.

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

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

Schema description coverage is 100%, with both parameters (path and output) already documented clearly. The description itself does not add parameter-level detail beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific action ('Zip'), a concrete resource (a project), enumerates the bundled files (.mblock, .bak, profile), and states the purpose (sharing/backup). This makes it immediately distinguishable from sibling tools like project-list, project-validate, or export_code, even without naming them.

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

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

The phrase 'for sharing or backup' provides clear intended-use context. It does not explicitly list alternative tools or say when not to use it, so it stops short of a 5, but the context is sufficiently clear for an agent to know when this tool 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?

Annotations already declare idempotentHint=true and destructiveHint=false, which the description does not contradict. It adds context that it saves to project.yaml and that it's a one-time setup. The 'Run once' recommendation is consistent with idempotency, so no contradiction.

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

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

Two sentences with zero filler. The primary purpose is front-loaded, and the usage instruction follows directly. No unnecessary 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?

For a simple setup tool with two well-documented parameters and idempotency covered by annotations, the description fully explains what the tool does, why it's used, and how often to run it. Nothing essential 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?

Schema description coverage is 100% for both parameters, so the schema fully documents them. The description only refers to 'path/target' without adding extra semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description explicitly states the action (save default project/target) and the resource (project.yaml), and explains its purpose ('so later block tools can omit path/target'). This clearly distinguishes it from sibling tools like project-open or project-new.

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 a clear usage instruction ('Run once per project') and implies sequencing by stating it enables later block tools to omit path/target. However, it doesn't explicitly name alternatives or when not to use it, but the purpose is unambiguous enough for an agent to decide.

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=false, idempotentHint=true, and destructiveHint=false. The description adds a safety framing ('safe way to try edits') but does not disclose operational details such as what happens if the destination already exists or whether the original project is left untouched.

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 front-loaded sentence with no fluff. It states the core action first and adds a meaningful parenthetical about safe editing.

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

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

For a simple two-parameter tool with annotations covering safety, the description is close to sufficient, but it still leaves the source 'path' parameter undocumented and gives only implied usage guidance. No output schema exists, so return behavior is also unaddressed.

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 only 50%, and the description does not compensate for the undocumented 'path' parameter. It mentions duplicating 'to a new path', which loosely maps to 'dest', but provides no clarification of the source 'path' parameter or how it relates to 'dest'.

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 ('Duplicate') and resource ('a project'), and clarifies the operation's purpose with 'safe way to try edits'. It is clearly distinguished from sibling tools like project-open, project-new, or project-archive by naming the duplication 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 phrase 'safe way to try edits' implies when the tool should be used, but it does not explicitly name alternatives or state when not to use it. The usage context is present but left to inference.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds minimal behavioral context by defining the file types scanned, but it does not disclose recursion behavior, output format, or ordering. It 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?

Two short sentences, no filler. The core action and resource are front-loaded, and the usage hint is delivered efficiently. Every word earns its place.

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

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

For a simple read-only list tool with one optional, fully documented parameter and strong annotations, the description is nearly complete. It could mention the output format (file paths vs names), but the absence is minor given the low complexity and clear purpose.

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

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

Schema description coverage is 100%: the 'root' parameter is already documented as the folder to scan with a default of MBLOCK_PROJECTS. The description adds no parameter information beyond the schema, so it meets the baseline for fully documented parameters.

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

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

The description states a specific verb ('List'), a specific resource ('.mblock/.sb3 projects'), and a scope ('under a folder'). The phrase 'Start here to find a project file' positions it as the discovery/listing tool and distinguishes it from siblings like project-open or project-validate.

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?

'Start here to find a project file' gives clear guidance on when to use this tool: as the entry point for locating projects. It does not explicitly name alternatives or state when not to use it, but the intended context is clear enough for an agent to select it for listing/discovery.

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 convey that this is a write operation (readOnlyHint=false), not idempotent, and not destructive. The description adds the template behavior but does not disclose what happens if the destination path already exists, whether files are overwritten, or what a successful call returns. There is no contradiction with annotations.

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

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

The description is a single, compact sentence that front-loads the action and resource, then lists the meaningful template options. Every word earns its place with 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?

For a low-complexity, two-parameter creation tool, the description plus schema give the agent enough to invoke it correctly. There is no output schema and the description does not mention result/error behavior, but that is a minor gap given the simplicity of the 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?

The schema already documents the path parameter as the destination .mblock path. The description repeats the template enum values and clarifies that they are templates, which is helpful, but it adds little semantic depth beyond what the enum and schema already offer. With 50% schema coverage, this is adequate but not compensatory.

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 ('Create'), the resource ('a new .mblock'), and the template options. It clearly distinguishes from read/project-management tools by emphasizing 'new,' but it does not explicitly differentiate from project-duplicate or other creation-like operations.

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 usage context is implied: use this tool when creating a new .mblock file. However, the description gives no explicit guidance on when to prefer this over sibling tools like project-duplicate, project-open, or project-import, and it does not mention exclusions.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds minimal behavioral context: it implies the tool reads a file and produces a summary, but doesn't specify whether it writes to the project state or just reads. Given the annotations cover safety, this is acceptable but not enriched; the description adds only the file-type detail.

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, concise and front-loaded with the verb and resource. It is under the typical length, which is acceptable for a simple tool. However, it could be more structured by separating the summary details, but it's not verbose. It earns a 4.

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 a single parameter fully described in the schema and rich annotations covering safety, the description is mostly complete for understanding what the tool does. However, it lacks what 'summarize' returns (output) and how it relates to sibling tools. Since there is no output schema, the description should describe the return format, but it doesn't. This gap lowers the completeness.

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 schema fully documents the 'path' parameter. The description does not repeat parameter details, which is fine. Since there is only one parameter and it's well-described in the schema, the description adds no new meaning but also doesn't need to. Baseline of 4 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 states a clear verb ('Open') and resource ('.mblock/.sb3') but the purpose is vague about what 'summarize' entails. There are many sibling tools (list_targets, list_blocks, get_block) that might handle specific summarization, but this tool's unique role is not explicit. The term 'summarize' could mean many things, and it doesn't clarify its scope relative to siblings.

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

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

The description gives no guidance on when to use this tool versus alternatives like project-validate, project-list, or list_targets. It doesn't state prerequisites (e.g., project must be attached or created first) or when to avoid it. An agent could confuse this with project-validate or project-list, and there's no hint to disambiguate.

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 cover readOnlyHint, idempotentHint, and non-destructiveness. The description adds valuable behavioral detail by listing exactly what is checked, which goes beyond the annotation metadata.

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 efficient sentences, each earning its place. The validation targets are front-loaded, and the usage timing is given immediately after. 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?

For a simple read-only validation tool with strong annotations covering safety, the description covers what is validated and when to run it. It doesn't describe the return format or how results are reported, but that is a minor gap given the tool's simplicity.

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, 'path', has no schema description and is not mentioned in the tool description at all. Since schema description coverage is 0%, the description should compensate, but it doesn't clarify how the path is used or what it should point to.

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

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

The description states a specific action ('Validate') with concrete targets: block links (parent/next), unknown opcodes, and missing x/y. This makes the tool's purpose immediately distinguishable from more general sibling tools like 'doctor'.

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 timing guidance: 'Run before sharing or injecting.' It does not name alternatives or state when not to use it, but the intended usage context is clear enough for an agent to decide.

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 this is a non-read-only, idempotent operation, so the description's job is lighter. It adds genuinely useful behavioral context by revealing that renaming also propagates to monitors' spriteName fields, which is a non-obvious side effect beyond simple mutation.

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, densely informative sentence with no filler. It front-loads the primary action and then adds the key side effect in a compact parenthetical.

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 covers the core purpose and a notable side effect, but with no output schema and no parameter documentation, it is missing guidance on optional parameters like 'confirm' and 'path'. An agent could reasonably infer the required parameters but may not know how to use the optional ones 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 0%, so the description carries the full burden of explaining parameters, but it does not. While 'target' and 'name' can be loosely inferred from the tool name, 'path' and especially 'confirm' are left completely unexplained, creating real ambiguity for invocation.

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 ('Rename') and a specific resource ('sprite/device target'), and it adds a distinguishing side effect (monitors' spriteName is updated). This makes the tool's function immediately clear and separates it from the various list/block/script manipulation siblings.

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

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

The intended use is implied by the phrasing: use this when you need to rename a target rather than edit blocks, scripts, or project settings. However, there is no explicit guidance about when not to use it or which sibling alternatives to prefer, such as set_block_field for field edits.

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 indicate the tool is a write operation (readOnlyHint=false), idempotent, and non-destructive, so the safety profile is already provided. The description adds nothing beyond the obvious 'set' action, but it does not contradict the annotations, so it meets a minimal standard given the annotation coverage.

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, front-loaded sentence with no extraneous words. It conveys the primary purpose immediately and wastes no tokens.

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 seven parameters, no output schema, and no parameter-level details, the description is far too sparse. It does not explain the confirm flag, the difference between 'input' and 'field' kinds, or the role of path and target, leaving critical gaps 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?

With schema description coverage at 0%, the description carries the full burden of explaining parameters. It mentions none of the seven parameters (kind, name, path, target, blockId, confirm, value), leaving the agent to infer their meaning from names alone, which is insufficient for correct invocation.

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

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

The description states a specific verb ('set'), a resource ('input param or dropdown field'), and a location ('on a block'), making the core action clear. It does not explicitly contrast with sibling tools like add_block or move_block, but the action is distinct enough that an agent can infer its purpose.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It simply states what the tool does without context about appropriate scenarios.

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