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

With no annotations, the description carries the full burden of behavioral disclosure. It states that a report is generated into a specific directory, but does not disclose whether an existing file is overwritten, what permissions are needed, what data source is used, or whether any side effects occur.

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 wasted words. It clearly names the action and target directory, though it sacrifices completeness for brevity.

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 generation tool with two optional parameters and no output schema, the description leaves notable gaps: it does not describe the generated report's structure, mention return values, or state prerequisites. It is minimally adequate but not complete for reliable autonomous 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%, and the description does not explain the 'output' or 'project' parameters. The schema provides default values that hint at their meaning, but the description adds no parameter-specific information, so it fails to compensate for the low coverage.

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

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

The description uses a specific verb ('Generate') and a specific resource ('Milestone 6E roster report'), and names the destination ('allowed generated-analysis directory'). This distinguishes it from siblings like bakugan_regenerate_m6e_contracts and bakugan_run_quality_suite, though it does not explain what the report contains.

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. Sibling tools such as bakugan_regenerate_m6e_contracts or bakugan_run_quality_suite are neither mentioned nor contrasted, leaving the agent to infer the appropriate selection 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?

With no annotations, the description carries the full burden. It discloses key behavioral traits: dry-run mode (no permanent effects), transactional execution (atomicity), and the 'allowed workspace' constraint. Though it doesn't detail side effects or prerequisites, these terms provide meaningful behavioral context beyond the schema.

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

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

The description is a single sentence, front-loaded with the action verb 'Run', and contains no filler. Every phrase adds meaning: transactional, installer, dry-run mode, allowed workspace.

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

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

Given no annotations and no output schema, the description should explain return values, prerequisites, and dependency relationships. It does not mention what the tool returns, what makes a workspace 'allowed', or any connection to sibling tools like bakugan_regenerate_m6e_contracts. Significant gaps remain for a 2-param tool.

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

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

Schema coverage is 0%, and the description only references 'workspace' as the target, leaving 'project' completely unaddressed. No additional meaning is provided for either parameter, such as formats, defaults, or what constitutes an 'allowed workspace'.

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 (run installer), the mode (dry-run), and the target (allowed workspace). It distinguishes this tool from siblings such as bakugan_regenerate_m6e_contracts and bakugan_analyze_m6e_roster by focusing on the installation process.

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 use for testing the installer without committing changes via the term 'dry-run', but it does not explicitly state when to use this tool versus alternatives or provide exclusions. Sibling tools are not mentioned as 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and method, but fails to mention potential side effects (e.g., overwriting existing contracts), required permissions, or failure behavior. For a regeneration tool, this is a critical gap.

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

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

The description is a single, concise sentence that front-loads the core purpose and method. There is no unnecessary information 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?

Given the tool's simplicity (one optional parameter, no output schema), the description covers the basic purpose and method. However, it lacks usage context, side-effect disclosure, and parameter explanation, making it only minimally complete for an agent to invoke confidently.

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 defines one optional parameter 'project' with a default, but provides no description. The tool description does not mention parameters at all, so with 0% schema description coverage, the agent has no guidance on what 'project' controls or how to use it.

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

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

The description uses a specific verb ('Regenerate'), identifies the resource ('Milestone 6E contracts'), and specifies the method ('using the repository-owned generator'). It clearly distinguishes this tool from sibling tools, which focus on ROM inspection, emulation, mutation, or validation.

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

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

The description implies the tool is used when Milestone 6E contracts need to be regenerated, but it does not explicitly state when to use it versus related tools like bakugan_install_m6e_dry_run or bakugan_analyze_m6e_roster. No exclusions or prerequisites are mentioned, leaving 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does mention a key safety trait (allowlisted, no arbitrary commands), but it fails to disclose side effects, permissions, output, or whether the run is read-only or mutating. Minimal context beyond the name.

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 the primary action front-loaded. It is brief and to the point, though slightly under-specified; however, for conciseness it earns high marks.

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 only two parameters and no output schema, but the description is too sparse. It doesn't explain what each stage does, what 'full' means, how to interpret results, or any side effects. For a tool that runs a verification suite, more detail is expected.

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 parameter explanations. While 'stage' has a self-explanatory enum (compile, ruff, mypy, tests, full), the 'project' parameter is entirely unexplained, and the description adds no meaning to the schema. The tool fails to compensate for the lack of schema descriptions.

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

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

The description clearly states the tool runs an allowlisted Bakugan verification stage, with the verb 'run' and a specific resource ('Bakugan verification stage'). The phrase 'without accepting arbitrary commands' adds a security scope. It doesn't explicitly distinguish from sibling tools like run_project_verification, but the 'allowlisted' qualifier implies a constrained subset.

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 run_project_verification or other bakugan_* tools. There is no mention of prerequisites, exclusions, or recommended scenarios. The description only implies usage for predefined stages.

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

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

With no annotations, the description discloses that data is 'integrity-checked', 'provider-neutral', and scoped to the 'current exact NDS ROM SHA', plus warns about the meaning of the prose. This adds meaningful behavioral context beyond the tool name, though it omits return format and error conditions.

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, no unnecessary words. Each sentence serves a distinct purpose: stating the function and providing a critical caveat.

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

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

The description is adequate for a simple read tool, but since there is no output schema, the absence of return format and behavior when no checkpoint exists leaves gaps. The caveat about not being ROM evidence is helpful, but completeness is limited.

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%, but the description contextualizes the `rom` parameter by mentioning the 'current exact NDS ROM SHA', indicating the parameter holds that SHA. It does not explicitly map the parameter name to the value or describe its format beyond what schema provides.

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

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

The description clearly states the tool reads 'the integrity-checked provider-neutral controller handoff state' for a specific ROM SHA, using a specific verb and resource. It distinguishes itself from sibling `controller_checkpoint_write` and other tools by focusing on reading handoff state.

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 checkpoint handoff state is needed and explicitly warns that the checkpoint is 'not authoritative ROM evidence', providing a when-not. It does not name alternative tools but gives clear context and an exclusion.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: atomicity ('Atomically write'), keying by exact ROM SHA, optimistic revision protection, bounded state size, and output path ownership. It does not elaborate on failure modes or return values, but the optimistic revision mechanism implies conflict handling.

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

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

The description is two concise sentences with no fluff. It front-loads the action ('Atomically write') and packs relevant constraints into the first sentence. Every phrase 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?

Despite the detailed schema and strong description, the tool has no output schema and the description does not explain return values or error behavior on revision conflicts. This is a gap for a mutating tool with optimistic concurrency, though the 'optimistic revision protection' phrase implies non-overwrite on conflict.

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

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

Although schema coverage is 0%, the description maps parameters to their roles: 'current exact NDS ROM SHA' explains the 'rom' parameter, 'optimistic revision protection' explains 'expectedRevision', and 'bounded provider-neutral controller handoff state' describes the 'state' object. This adds semantic meaning beyond the raw schema.

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

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

The description clearly states the tool's verb ('Atomically write') and resource ('bounded provider-neutral controller handoff state') with specific scope ('for the current exact NDS ROM SHA'). It distinguishes itself from sibling controller_checkpoint_read by focusing on write semantics and adding details like optimistic revision protection.

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 tool's use case explicit: it writes handoff state, so an agent can infer when to use it (to persist controller state) versus reading via controller_checkpoint_read. However, it does not explicitly mention alternatives or exclusions, leaving some inference to the agent.

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

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

No annotations are provided, so the description is the only source of behavioral info. It reveals the breakpoint is bounded and constrained to an allowlisted range, but omits details about failure behavior, persistence, side effects, or prerequisites like a running emulator. The term 'bounded' is vague and does not adequately disclose the tool's operational traits.

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 clear sentence that is front-loaded and free of fluff. However, given the tool has four parameters and no other documentation, the extreme terseness leaves out essential information, making it slightly under-specified for the complexity.

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

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

With no annotations, no output schema, and no parameter explanations, the description leaves major gaps about address validation, mode options, symbol usage, rangeId semantics, and possible errors. The single sentence is far from sufficient for a 4-parameter tool.

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

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

The schema describes address, mode, symbol, and rangeId, but the description gives no semantics for any of them. Schema description coverage is 0%, and the description does not compensate by explaining how these parameters should be used or their constraints beyond what the schema already shows.

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 ('Install') and identifies the resource ('ARM9 software breakpoint') with a key constraint ('bounded inside an allowlisted executable range'), clearly distinguishing it from sibling tools like desmume_breakpoint_remove and desmume_breakpoint_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?

It indicates the breakpoint must be inside an allowlisted executable range, which gives clear context for when it's applicable. However, it does not explicitly contrast with alternative tools or mention exclusions, but the constraint alone provides sufficient guidance for selection.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. It discloses read-only intent through 'List', plus session scope and hit count data. It does not describe output format or potential lack of breakpoints, but these are minor for a list operation.

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 with no filler. It leads with the verb and object, making it immediately scannable.

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 list operation, the description provides key context: session scope and the data included (breakpoints and hit counts). Without an output schema, it could be slightly more explicit about return formatting, but the tool's simplicity makes this adequate.

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 accepts zero parameters, confirmed by the empty schema. A baseline of 4 applies because there is no parameter information to convey.

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 ('List') and resource ('session-scoped breakpoints'), and adds 'hit counts' to distinguish it from add/remove breakpoint siblings. It clearly identifies the tool's function and output.

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

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

The description clearly implies usage for inspecting breakpoints in the current session, which is distinct from breakpoint add/remove siblings. However, it does not explicitly mention when not to use it or compare it with alternative tools like desmume_status.

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

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

With no annotations, the description carries the full burden. It discloses that the breakpoint must be from this session, which is a useful behavioral detail, but it does not discuss error handling, idempotency, or side effects. This is minimal but not misleading.

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, direct sentence with no unnecessary words. It is front-loaded with the action and resource, making it easy to parse.

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 with one parameter and no output schema. The description explains what it does but does not cover return values, failure conditions, or post-condition state, leaving some gaps for the agent. It is adequate but not rich.

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 adds meaning to the 'id' parameter by indicating it refers to a breakpoint previously installed by this debugger session, which is beyond the schema's pattern definition. It does not, however, describe how to obtain the id or what happens if the id is invalid.

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 'remove' and the resource 'breakpoint', and it is specific about the scope ('previously installed by this debugger session'), which distinguishes it from sibling tools like desmume_breakpoint_add and desmume_breakpoint_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 provides an explicit constraint that the breakpoint must have been installed by this debugger session, giving a clear when-not condition. However, it does not explicitly mention alternatives like list or add, so it falls short of 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?

No annotations are provided, so the description carries the full burden. It discloses 'atomically' and 'without interpreting' but omits critical behavioral context: whether the emulator must be paused, whether the operation modifies emulator state, file output location, or any side effects. This is insufficient for a tool with no annotation safety hints.

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

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

The description is a single, highly concise sentence with no filler. It front-loads the core action and key qualifiers efficiently, earning its place despite its brevity.

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 no annotations, no output schema, and three parameters. The description gives only a high-level overview, omitting prerequisites (e.g., running emulator, pause state), file format details, and how the regions parameter is used. This is inadequate for an agent to invoke it correctly without further inference.

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

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

Schema description coverage is 0%, and the description does not elaborate on the meaning of 'output', 'project', or 'regions'. The description mentions 'memory regions' but does not map to the regions parameter or explain the output structure. With three undocumented parameters, the description provides negligible semantic value.

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: 'Atomically save raw ARM9 registers and bounded memory regions without interpreting them.' The verb 'save' combined with the resource (ARM9 registers and memory regions) is unambiguous. It also differentiates from sibling read/analysis tools by emphasizing atomicity and non-interpretation.

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 its use for capturing raw runtime evidence without interpretation, but it does not explicitly state when to prefer this tool over alternatives like desmume_capture_stop_context or desmume_read_memory. There is no explicit exclusion or alternative mention, leaving the decision to the agent.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It mentions that the capture is 'decoded' and 'bounded' but does not state whether the operation is read-only, what 'bounded' means in practice (e.g., memory length limits), whether a GDB connection is required, or what side effects (if any) the tool has. This is insufficient for an agent to understand the tool's behavior beyond its basic action.

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 that directly states the tool's purpose without extraneous words. Every word earns its place, and the most important information (capture registers and memory around PC/SP) appears first.

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

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

Given the tool's moderate complexity (two parameters, one a nested array for additionalRegions) and the absence of an output schema, the description is too sparse. It omits any explanation of what the returned context looks like and does not mention the additionalRegions parameter, leaving the agent without critical information for correct invocation.

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

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

The schema has 0% description coverage, and the description does not mention either parameter (timeoutMs or additionalRegions). An agent cannot infer that additionalRegions allows specifying extra memory regions to capture, nor does it understand the purpose of timeoutMs. The description adds no value to the parameter understanding.

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

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

The description uses the specific verb 'capture' and specifies the resource: 'decoded ARM9 registers and bounded memory around the current stopped PC and SP.' This distinguishes it from sibling tools like desmume_read_register_packet (which reads raw registers) and desmume_read_memory (which reads raw memory), making the tool's purpose unambiguous.

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

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

The phrase 'current stopped PC and SP' implies the tool is intended for use when the emulator is stopped, but it does not explicitly say when to use this tool versus alternatives like desmume_read_register_packet or desmume_read_memory. No exclusions or alternative tools are mentioned, so the guidance is only implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions a bounded interval and return of a stop/timeout, but does not explain side effects (e.g., resuming execution changes state), prerequisites, or what constitutes a 'stop'. The captureContext parameter is not mentioned, so the tool's context capture behavior is hidden.

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, direct and free of filler. It front-loads the action and outcome, making it easy to parse quickly.

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 4 optional parameters, no output schema, and no annotations, making the description the only source of context. It does not explain return value structure, prerequisites, or how this relates to other wait/step/capture tools. For a debugger control operation, this is insufficient.

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 4 parameters with 0% description coverage. The only hint is 'bounded interval' which likely maps to timeoutMs, but timeoutMs, captureContext, additionalRegions, and expectedBreakpointId are not explained. Given the low coverage, the description should compensate, but it does not.

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 verb ('Continue') and resource ('ARM9 execution') with the expected outcome ('return the first observed stop or timeout'). It is unambiguous and distinct from the sibling tools at the action level, though it does not explicitly call out alternatives.

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 vs. alternatives such as desmume_step_instruction or desmume_wait_for_stop. It does not mention prerequisites, e.g., that the emulator must be paused or that a breakpoint must be set, so usage context is lacking.

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

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

With no annotations, the description carries the full burden. It does disclose that the change is 'session-scoped', implying the modification is not persistent, which is useful. However, it does not mention validation behavior, atomicity, or effects on the emulator runtime, leaving significant gaps.

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 unnecessary words. It states the verb and the object clearly, making it highly concise and easy to parse.

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 complex schema and absence of an output schema or annotations, the description is too sparse to guide an agent on the tool's role in a workflow or its return behavior. It lacks information on when to invoke it relative to other desmume tools or what outcomes to expect.

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

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

The description adds no detail about the 'ranges' parameter beyond its name, even though the schema is complex with nested properties. Since schema description coverage is 0%, the description should compensate, but it only implicitly connects 'executable-range' to 'ranges' without any format, constraints, or examples.

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

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

The description uses the specific verb 'Replace' and identifies the resource as the 'session-scoped additional ARM9 executable-range allowlist', clearly distinguishing it from sibling breakpoint and memory tools. However, it does not explicitly mention when this tool should be used over alternatives, so it falls short of a 5.

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

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

No guidance is provided on when to use this tool versus alternatives like desmume_breakpoint_add or desmume_breakpoint_list. The description only states the action itself and gives no context on prerequisites, exclusions, or typical scenarios.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It does reveal that the tool interrupts and waits with a bounded timeout, but omits crucial behaviors like what happens on timeout, whether the target is left paused or resumable, and how captureContext/additionalRegions affect execution.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It conveys the core action and result efficiently, 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?

Despite having three parameters, no annotations, and no output schema, the description provides almost no operational context. It does not explain return behavior, timeout semantics beyond 'bounded', side effects on the target, or relationship to sibling tools, leaving significant gaps for an agent.

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 hints at timeoutMs through 'bounded interval', but gives no meaningful explanation for captureContext or additionalRegions. This is thin compensation for three undocumented optional 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 clearly states a specific action ('Interrupt a running ARM9 target') and outcome ('wait a bounded interval for its stop reply'), making the tool's purpose unmistakable. It does not explicitly contrast with sibling tools like desmume_stop or desmume_wait_for_stop, so it loses a point for missing differentiation.

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 usage guidance is provided. The description does not say when to prefer this tool over desmume_stop, desmume_continue, or desmume_wait_for_stop, nor does it mention any prerequisites or exclusions. The context is implied but not explained.

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?

No annotations are provided, and the description gives no behavioral details. It does not disclose side effects, whether it is safe/read-only, what happens on failure, or what the tool actually does beyond 'probe'. The description carries the full burden of behavioral transparency and fails to provide it.

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 concise—a single short sentence with no wasted words. However, it is under-specified, omitting any context about what 'probe' entails or what the result is. It is appropriately short but too terse to fully serve the agent.

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

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

Given that there is no output schema and no annotations, the description should explain what the tool returns or what constitutes a successful probe. It only names the action and target, leaving the behavioral contract unclear. For a simple tool this might be sufficient, but the lack of any expected outcome or edge-case information makes it 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?

The tool has 0 parameters, and the schema is complete with 100% coverage. The description adds no parameter information, but none is required because there are no parameters. The baseline score for 0 parameters is 4, which is appropriate here.

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

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

The description uses a specific verb ('Probe') and names a concrete resource ('the owned localhost ARM9 GDB port'), which distinguishes it from sibling tools like desmume_status or desmume_start. However, 'probe' is somewhat ambiguous—it could mean checking connectivity, sending a test packet, or waiting for availability—so it is not a perfect 5.

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

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

No usage guidance is provided. The description does not state when to use this tool, whether it should follow desmume_start or desmume_wait_for_gdb, or how it differs from desmume_status. There are no calls to alternatives or exclusions, leaving the agent without contextual 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?

With no annotations, the description carries the full burden for behavioral disclosure. It mentions the GDB RSP mechanism and the 4096-byte cap, but omits error behavior, return format, and the impact of invalid addresses. The phrase 'at most' hints at partial reads but does not explain why.

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 wasted words. It succinctly communicates the core operation and constraint.

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

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

Given no output schema or annotations, the description should explain return values, failure modes, and the dependency on an active GDB session. It does none of these. The brief description is sufficient only if the agent already understands the debugger context from sibling tools.

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 adds little beyond the schema. 'Address' and 'length' are self-explanatory from the property names, and the 4096-byte maximum repeats the schema constraint. No additional meaning is provided for special cases like endianness or memory regions.

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 ('read'), resource ('ARM9 memory'), and constraint ('at most 4096 bytes'), and it distinguishes from sibling tools like desmume_read_register_packet by specifying memory rather than registers.

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 such as nds_inspect_rom, nor are prerequisites like an active GDB connection mentioned. The description only states what it does, not when to choose 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states that it reads a raw packet, with no mention of side effects, failure modes, or prerequisites. The return format and how the raw packet relates to emulator state are also undisclosed.

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. It is front-loaded with the action and resource, making it easy to parse quickly.

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, but the description is too terse to be fully complete. It does not explain what the raw ARM9 GDB register packet contains, when to use this read operation, or any dependencies on the emulator state. Without an output schema, the description should clarify the return value but does not.

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

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

The tool has zero parameters, so the schema is empty and the description adds no parameter information. Per the baseline rule for 0-parameter tools, this is acceptable; no additional semantic clarification is needed.

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

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

The description clearly identifies the action ('Read') and the specific resource ('raw ARM9 GDB register packet'), distinguishing it from sibling tools like desmume_read_memory. The verb+resource pairing is unambiguous and specific.

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 desmume_read_memory or desmume_capture_stop_context. The description only states what it does, without explaining the appropriate context or prerequisites (e.g., needing an active GDB connection or paused emulator).

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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the action and parameters, omitting details such as whether the call blocks, whether it validates the ROM, whether it starts a background process, or what happens on failure. The word 'verified' is ambiguous and not explained.

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 leads with the verb and includes only necessary information. There is no redundant or filler content, and it is appropriately front-loaded.

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 startup tool with three parameters, no annotations, and no output schema, the description is too sparse to be operationally complete. It does not explain the launch behavior, return values, or how to verify a successful start—critical details for an agent to use it correctly in a debugging workflow.

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

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

The description adds meaning for 'rom' (local ROM) and 'arm9GdbPort' (ARM9 GDB port), but leaves 'launcher' unexplained beyond the tool name. With 0% schema coverage, the description partially compensates but does not fully clarify all parameters, especially the required 'launcher' field.

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 (Start), the resource (verified DeSmuME debug launcher), and the key parameters (one local ROM, ARM9 GDB port). This distinguishes it from sibling tools like desmume_stop and desmume_status, which handle different lifecycle stages.

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

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

The description implies this is the entry point for a debug session but does not explicitly state when to use it versus alternatives, nor does it mention any prerequisites or exclusions. The context suggests use before other desmume_* lifecycle tools, but that guidance is not spelled out.

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?

No annotations are provided, so the description must carry the full burden. While 'Report' implies a read-only operation, the description fails to disclose whether the process must be running, what happens if it isn't, or what the report contains (e.g., PID, state). This lack of transparency is a gap for an agent deciding whether to call the tool.

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 with no filler or redundancy. It immediately conveys the essential purpose, which is ideal for a simple status tool.

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

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

Given the tool's simplicity (0 params, no output schema), the description is adequate for understanding its basic function but incomplete about expected output and edge cases. It does not specify what the 'report' includes or any error behavior, which an agent might need to interpret the result.

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 is an empty object, so no parameter documentation is needed. The baseline for 0 params is 4, and the description does not add anything unnecessary about 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 clearly states the tool's function: 'Report the single DeSmuME process owned by this RE-MCP server instance.' It uses a specific verb ('Report'), names the resource (DeSmuME process), and specifies scope ('single', 'owned by this instance'), distinguishing it from sibling tools like desmume_start or desmume_stop.

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 usage guidance is provided. The description does not mention when to use this tool versus alternatives, nor does it give any context on prerequisites or exclusions. The only implicit hint is that it reports status, but this is not explicitly contrasted with other desmume_* tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions a 'bounded wait per step' and the instruction count range, but it does not disclose side effects like mutating CPU state, whether the emulator must be paused, whether breakpoints are respected, or what the tool returns after stepping.

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 that captures the core action, range, and a key behavioral trait. Every word earns its place with no unnecessary 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?

This is a debugging control tool with four parameters (including a nested array) and no output schema or annotations. The description is too sparse to convey essential context such as expected emulator state, return values, what additionalRegions does, or how this step operation interacts with breakpoints and pauses.

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 implicitly references the 'count' parameter via '1 through 100', but it does not explain captureContext, perStepTimeoutMs, or additionalRegions. The description adds minimal meaning beyond the raw schema.

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

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

The description uses a specific verb 'Single-step' with a clear resource ('ARM9 instructions') and a scope ('1 through 100'). It inherently distinguishes from sibling tools like desmume_continue and desmume_pause by describing a controlled, instruction-by-instruction execution.

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 tool name and description imply its use for stepping through ARM9 instructions, but it provides no explicit when-to-use or when-not-to-use guidance, nor does it name alternative tools like desmume_continue. The context is implied rather than clearly 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?

Without annotations, the description must carry the full burden of disclosure. It adds the ownership constraint, but omits any side effects such as whether the process is terminated gracefully, whether state is saved, or whether the process can be restarted. The action is destructive yet lacks consequences.

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 redundant words. Every word earns its place, conveying the action and the ownership limitation.

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 stop command, the description is minimally adequate. It identifies the target and action, but given the absence of output schema and annotations, it would benefit from noting post-conditions (e.g., whether subsequent desmume_start is needed). It is complete for the basic action but lacks behavioral context.

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 takes zero parameters, and schema coverage is 100% (vacuously). With no parameters, the description cannot add parameter-level detail; baseline for zero parameters is 4, and there is no gap to compensate.

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 verb 'Stop' plus resource 'the owned DeSmuME process' clearly states the action and target. The qualifier 'only the owned' distinguishes it from stopping arbitrary processes and from sibling pause/terminate tools.

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

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

The description implies usage for halting the currently owned emulator session, and the 'only' qualifier sets an exclusion (do not use on unowned processes). However, it does not explicitly compare to alternatives like desmume_pause or desmume_continue, nor specify when to prefer this over other control commands.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only mentions a 'bounded interval' without explaining what happens when the interval expires (e.g., error, false return, or continued waiting). It also doesn't state whether the tool modifies emulator state or is purely observational.

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 concise at one sentence, but it is under-specified. While it avoids verbosity, it omits essential details about the wait outcome, making it less useful than a similarly short but more informative description.

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 no output schema, the description should clarify the wait's termination conditions and timeout behavior. It doesn't state what constitutes success or failure, and the meaning of 'owned' is unexplained, leaving the tool's behavioral contract 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?

The schema documents timeoutMs with default, minimum, and maximum, but the description adds no parameter-specific meaning. The phrase 'bounded interval' indirectly references the timeout, but doesn't explain how to set it, what values are appropriate, or what the return value indicates.

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 'Wait' and names the resource 'owned ARM9 GDB port', making it clear that this tool performs a waiting operation. However, it doesn't specify exactly what 'wait for' means (e.g., port readiness vs. a response), which keeps it slightly indistinct from related tools like desmume_probe_gdb.

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

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

The description provides no guidance on when to use this tool versus alternatives such as desmume_probe_gdb or desmume_wait_for_stop. There are no use-case conditions, prerequisites, or exclusions 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?

With no annotations, the description carries the full burden of behavioral disclosure. It mentions waiting on a running target, but does not explain timeout behavior, what happens if the target is already stopped, failures, or whether this command interacts with breakpoints. This is a significant gap.

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

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

The description is a single sentence, front-loaded with the key action. It avoids unnecessary words, but its brevity comes at the cost of missing behavioral and parameter information. Given the need for more detail, a longer description could still be concise.

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 three parameters, no output schema, and no annotations. The description explains the basic purpose but not return values, side effects, timeout semantics, or parameter usage. For a tool that likely interacts with emulator state, the description 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?

The input schema has 0% coverage from the description, and the description does not mention any of the three parameters (timeoutMs, captureContext, additionalRegions). The agent must rely solely on the schema, which provides minimal semantic guidance. The description adds no value for 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 clearly states the tool's specific action: waiting for a currently running ARM9 target to stop. The phrase 'without issuing a new continue command' distinguishes it from the sibling desmume_continue and implies it is used after a continue or step has been issued.

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

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

The description implies when to use this tool: when an ARM9 target is currently running and you want to wait for it to stop naturally. It does not explicitly mention alternatives or exclusions, but the context is clear enough for a user familiar with the desmume tool family.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states that the tool reads Git status, without explaining what the status includes, whether the project must already exist, or what happens if the project is invalid or the path is incorrect.

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 that efficiently conveys the core purpose with no unnecessary words. It is appropriately concise.

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

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

Despite the tool's simplicity (one parameter), the description lacks crucial contextual details such as the return value format, the exact meaning of 'project' in relation to the workspace root, and error behaviors. It is minimally viable but leaves significant gaps for an agent to invoke it correctly.

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

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

Schema coverage is 0%, so the description must compensate by explaining the 'project' parameter. It merely refers to 'one project', leaving unclear whether this is a name, path, or ID, and how it relates to the configured workspace root.

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 ('Read') and resource ('Git status'), and scopes it to 'one project under the configured workspace root', clearly distinguishing it from any sibling tool focused on other operations. It is unambiguous and has a precise 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 implies a use case but does not provide explicit guidance on when to use this tool versus alternatives. It mentions no prerequisites, no exclusions, and does not reference related tools such as run_project_verification.

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

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

With no annotations provided, the description must carry the disclosure burden. It reveals that the graph is 'bounded' and that calls are not traversed, which are key behavioral traits. However, it does not explain what happens when an entry point is not uniquely mapped, how bounds are enforced, or whether the operation is read-only (likely, but not stated). It also omits any error behavior or output structure.

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, packing a lot of specificity into a compact form. It is front-loaded with the main action and modifiers. It sacrifices some clarity for brevity, but remains 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?

Given the tool's complexity (10 parameters, no output schema, no annotations), a one-sentence description is insufficient. It fails to explain the meaning of parameters, the structure of the output graph, preconditions like 'uniquely mapped', or any side effects. The description only partially fulfills the information needed to use the tool safely and effectively.

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 10 parameters with 0% description coverage, yet the description mentions none of them by name. Terms like 'one uniquely mapped entry point' are not tied to specific parameters (e.g., runtimeAddress or romOffset). The description adds virtually no meaning to help understand the parameters, leaving the agent to guess how to invoke 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 uses a specific verb ('Build') and a clear resource ('direct-control-flow graph') with explicit constraints: 'bounded', 'from one uniquely mapped entry point', and 'without traversing calls'. This distinguishes it from sibling tools like nds_analyze_function (which likely follows calls) and nds_disassemble_range (which produces disassembly, not a graph).

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

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

The phrase 'without traversing calls' implies the tool is for control flow analysis that stops at call boundaries, giving some sense of when to use it versus a call-graph tool. However, it does not explicitly name alternatives or provide guidance on when to choose this over related tools like nds_analyze_function or nds_discover_functions. Guidance is implied rather than stated.

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

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

With no annotations available, the description carries the full transparency burden. It reveals important behavioral details: it distinguishes complete negative from inconclusive proof and only analyzes the CFG once proof succeeds. However, it does not mention read-only nature, required inputs, or error handling, so some gaps remain.

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 primary purpose and packs multiple constraints without filler. It is concise but slightly overloaded with three clauses, making it efficient yet dense.

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 17 parameters, no output schema, and no annotations, the description offers only a high-level purpose and one behavioral nuance. It does not specify return structure, failure modes, or how proofScope and seeds interact, leaving significant gaps for agent 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 vaguely references evidence ('program-entry or deterministic direct-call evidence') and ARM/Thumb mode, but does not explain the many proof/cfg limits (maxCfg*, maxProof*) or the proofScope parameter. With 17 parameters, the description adds only minimal semantic value.

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 starts with 'Prove one Nintendo DS ARM/Thumb function entry', clearly stating the action and resource. It also specifies meaningful outcome distinctions (complete negative vs. inconclusive) and a bounded CFG analysis condition, distinguishing itself from sibling tools like nds_disassemble_range or nds_analyze_control_flow.

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 prerequisites ('from program-entry or deterministic direct-call evidence') and conditional behavior ('analyze its bounded CFG only when proven'), but it does not explicitly state when to choose this over alternatives such as nds_discover_functions or nds_analyze_control_flow. The guidance is implied rather than clearly directed.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so meaningfully: it explicitly states 'without resuming execution' and 'read-only Ghidra project', assuring the agent this is a non-mutating and non-execution operation. It also hints at a prerequisite ('already-current') for Ghidra enrichment. It does not describe the return value or failure modes, but the key safety-relevant behavior is covered.

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 verb and resource, then appends necessary qualifiers about Ghidra and non-resumption. It is efficient but somewhat jargon-heavy and could be slightly reorganized for readability. Every clause adds meaningful context, so it earns a 4 rather than a 3.

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

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

This is a complex tool with 5 parameters, no output schema, and no annotations. The description explains the high-level purpose and non-resumption constraint but does not clarify what 'bounded canonical static evidence' means, what the tool returns, or how the parameters influence behavior. For an agent to invoke it correctly, significantly more detail 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?

The input schema has 5 parameters with 0% description coverage, so the description must compensate. It only vaguely maps to parameters via phrases like 'optionally enriching from an already-current read-only Ghidra project' (suggesting includeGhidra/decompileGhidraFunction) and 'bounded canonical static evidence' (suggesting referenceLimit). Parameters such as timeoutMs and nearbyInstructions are completely unexplained. This is insufficient for a 5-parameter 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 precisely states the tool's action: 'Correlate the current stopped server-owned DeSmuME ARM9 state with the exact launched NDS ROM and bounded canonical static evidence'. This clearly distinguishes it from sibling tools like desmume_capture_stop_context (which captures context) and nds_resolve_rom_offset (which resolves single offsets). The verb 'correlate' plus the specific resources involved makes the purpose unambiguous.

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

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

The description conveys clear usage context by requiring a 'current stopped' state and noting that the tool operates 'without resuming execution'. It also indicates optional use of an 'already-current read-only Ghidra project', suggesting when Ghidra enrichment is appropriate. However, it does not explicitly name alternative tools or state when not to use this tool, so it stops short of 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?

With no annotations provided, the description carries the full behavioral burden. It discloses that the window is 'bounded' and requires a 'uniquely mapped code source,' which is useful, but it omits side effects, output format, or any safety/readonly indication. The description lacks detail on what happens with incomplete instructions or how the bound limits apply.

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 is concise and to the point, but the brevity leaves out critical details, making it slightly under-specified for such a parameter-rich tool.

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

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

Given 8 parameters, no annotations, and no output schema, the one-line description is severely incomplete. It doesn't explain how to specify the range, what the output looks like, or how this tool fits into a workflow. The lack of anything beyond a high-level purpose makes this minimally useful for correct invocation.

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

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

The description adds minimal parameter context via phrases like 'ARM/Thumb' (mode), 'bounded' (maxBytes/maxInstructions), and 'code source' (rom/overlayId), but schema description coverage is 0% and none of the 8 parameters are explicitly explained. It fails to clarify required parameters rom and processor or the difference between romOffset and runtimeAddress.

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 decodes a bounded ARM/Thumb instruction window from a Nintendo DS code source, using the specific verb 'Decode' and naming the resource. However, it doesn't explicitly differentiate from sibling analysis tools like nds_analyze_function or nds_discover_functions, so it loses some 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?

There is no guidance on when to use this tool versus alternatives. No exclusions, prerequisites, or comparisons to sibling tools are given, leaving the agent to infer the use case from the name and terse description.

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-obvious behavioral context by stating that the call graph is bounded and proven only by program-entry or deterministic resolved direct-call evidence. This informs the agent about the tool's conservative and deterministic nature. However, with no annotations, it fails to disclose side effects, resource usage, or return value semantics.

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

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

The description is a single sentence with no filler words, front-loading the central verb and object. It is concise and avoids redundancy, though the technical jargon ('deterministic resolved direct-call evidence') makes it dense and slightly less accessible.

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 15 parameters, 3 required, and no output schema, a one-sentence description is inadequate. It does not explain how to configure scope or seeds, what the returned call graph looks like, or what budget limits affect. The complex nature of the tool demands significantly more context.

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

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

Schema description coverage is 0%, and the description names none of the 15 parameters. The agent is left to infer the meaning of 'rom', 'processor', 'scope', 'seeds', and every 'max*' budget parameter from schema types and defaults alone, with no compensatory explanation in the description.

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 ('Discover a bounded call graph') with a well-defined resource ('Nintendo DS ARM/Thumb function entries') and evidence criteria. It is distinct enough to imply uniqueness among siblings, but it does not explicitly differentiate itself from related analysis tools like nds_analyze_control_flow or nds_analyze_function.

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. The description explains what it does but not the situations that would favor this tool over nds_analyze_function, nds_list_references, or nds_ghidra_list_calls. No exclusions or alternative mentions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that output is 'deterministic' and that the tool is selective (not dumping all assets), but it omits critical details such as what the bundle contains, whether it writes files to disk, or what the return value represents. This is a significant gap for a tool with zero 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 sentence with no fluff, making it concise and front-loaded. It earns its place by conveying the core action and a key distinguishing trait. However, its brevity means it sacrifices important details, leaving it short of a 5.

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

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

With no output schema and no annotations, the description must compensate by explaining return values, side effects, and context, but it only offers a high-level action. The tool itself is simple (1 param), yet the description leaves major gaps about what the agent should expect before and after invocation, making it 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?

The input schema has a single 'rom' parameter with no description, and schema coverage is 0%. The description never mentions the parameter, so the agent receives no guidance on what value to pass (e.g., file path, ROM name) or its format. With the description failing to compensate for the missing schema descriptions, the parameter semantics are essentially undocumented.

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 ('Generate') and resource ('deterministic NDS static-analysis bundle'), which clearly differentiates it from a full asset dump. However, it does not explicitly name a sibling alternative, so it lacks the explicit sibling differentiation seen in top-tier examples.

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

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

The phrase 'without dumping every NitroFS asset' implies a lighter-weight use case compared to full extraction, but there is no explicit 'when to use' or 'when not to use' guidance, nor any named alternative like nds_extract_component. This is sufficient for basic inference but not explicit enough for an AI to confidently choose between tools.

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

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

With no annotations, the description carries full behavioral burden. It mentions 'validated' and the destination tree, but does not disclose side effects (e.g., whether files are overwritten), failure modes, or required prior steps. The agent is left uncertain about mutability and safety.

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 adds meaning, and it is appropriately sized for the purpose it does communicate.

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 five parameters, no annotations, and no output schema, the description is far too minimal. It fails to explain return values, error conditions, or the overall extraction workflow, making it incomplete for agent decision-making.

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 only vaguely maps to the 'component' parameter by listing component types. It does not explain 'rom', 'fileId', 'filePath', 'overlayId', or their relationships, so the description fails to compensate for the lack of schema descriptions.

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 names the action (extract), the resource types (ARM9, ARM7, overlay, NitroFS component), and the destination (server-controlled generated-analysis tree). This is specific enough to distinguish it from sibling tools like nds_list_files or nds_extract_analysis_bundle.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or explicit comparison to other extraction or listing tools, leaving the agent to infer appropriate usage from the tool name alone.

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

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

With no annotations provided, the description carries the burden and does contribute useful behavioral context: it states the operation is bounded, deterministic, and does not infer loaded overlay state. However, it does not disclose return format, failure modes, or whether the operation is read-only, leaving gaps in what the agent can expect.

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 entire description is one front-loaded sentence with no filler—every phrase ('bounded', 'deterministic', 'proven', 'static scope', 'without inferring loaded overlay state') contributes meaning. It is appropriately compact for the amount of high-level context it conveys.

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 complex tool with 12 parameters, no output schema, and no annotations, a single high-level sentence is insufficient. The description does not cover parameter interactions, return values, or practical constraints beyond 'bounded', so an agent would need to rely heavily on the schema and external knowledge.

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 0% description coverage, so the description must compensate, but it only hints at three concepts ('scope', 'seeds', 'bounded') and does not explain the 12 individual parameters. Key parameters like targetRomOffset, maxBytes, maxComponents, and scope kinds remain underspecified, leaving the agent to rely on names and constraints alone.

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 ('Find') with a clear resource (xrefs in Nintendo DS static scope) and adds qualifiers like 'bounded deterministic proven' and 'without inferring loaded overlay state' that distinguish it from more general reference-finding tools. However, it does not explicitly name sibling tools or contrast itself with them, so it falls just short of a perfect score.

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 context is implied by phrases like 'caller-selected Nintendo DS static scope' and 'using explicit/proven seeds'—an agent can infer it should be used when static, bounded xrefs are needed and seeds are available. There is no explicit when-not-to-use guidance or mention of alternatives like list_references, so it stays at a middle score.

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?

Since annotations are absent, the description carries full responsibility. It discloses a non-destructive aspect ('safely reconcile') and a scoping mechanism ('full-SHA-scoped'), which adds behavioral context. However, it does not mention potential side effects like disk writes, required permissions, or what happens if the project already exists beyond 'safely reconcile'. It is not misleading but remains incomplete.

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 with no wasted words. It efficiently packs the core purpose, scope, and constraints. However, it uses heavy jargon ('full-SHA-scoped', 'RE-MCP-owned') that might obscure readability, though it is concise and front-loaded.

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 of bootstrapping a Ghidra project, the description provides only the essential purpose and constraints. It lacks details about return values, error conditions, or typical usage flow (e.g., checking status with a sibling tool). With no annotations and no output schema, the description is serviceable but not fully complete for an agent to invoke it without prior knowledge.

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 must explain the 'rom' parameter. It only refers to a 'canonical Nintendo DS ROM' without specifying the expected format (path, ID, hash) or how it relates to the parameter. The input schema alone provides only a generic string type, so the description adds minimal meaning beyond the parameter name.

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 ('Create or safely reconcile') on a specific resource ('one full-SHA-scoped Ghidra project for a canonical Nintendo DS ROM'), which distinguishes it from sibling tools like status or inspect functions. The phrase 'full-SHA-scoped' and 'canonical' add precision, making its purpose unmistakable.

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

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

The description implies this is the bootstrap step for Ghidra projects but does not explicitly say when to use it vs alternatives. It mentions constraints ('using only the configured analyzeHeadless installation and RE-MCP-owned scripts') but lacks explicit exclusions or alternative references. Usage is implied by the tool name and context, but no direct guidance is given.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly states 'Runs read-only with auto-analysis disabled' and 'bounded', which are key behavioral traits. It does not describe error conditions or what defines a 'current' project, but the disclosed traits are substantive and match the tool's likely safety profile.

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

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

The description is two sentences, front-loaded with the primary purpose and then adding a concise operational note. It contains no redundant words or filler, making it optimally concise.

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

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

With no output schema and no annotations, the description needs to cover return format and failure modes, but it only vaguely describes the output as 'C-like decompiler output'. It clarifies the operational mode and bound, but leaves gaps around expected output structure, potential errors, and how the function is identified (e.g., runtimeAddress).

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 explain any of the five parameters. While 'bounded' hints at maxCharacters and 'canonical' hints at runtimeAddress, there is no explicit mapping or semantic elaboration. The parameter names are self-explanatory to some degree, but the description adds minimal value beyond the schema.

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

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

The description clearly states the tool's action ('Return bounded Ghidra-derived C-like decompiler output') and scope ('for one canonical NDS function'), distinguishing it from siblings like nds_disassemble_range and nds_analyze_function which focus on disassembly or analysis rather than decompiler output. It also specifies the prerequisite 'already-current project', clarifying the context.

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

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

The description provides clear context: it should be used on a project that is already current, and it runs read-only with auto-analysis disabled. However, it does not explicitly name alternatives or state when not to use this tool, so it falls short of 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?

With no annotations provided, the description carries the full burden. It discloses two key behaviors: read-only operation and auto-analysis disabled, which is useful context. However, it does not explain what happens if the project is not current, what 'function metadata' includes, or potential error conditions, so it is only moderately transparent.

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

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

The description is two sentences, front-loaded with the primary action, and every phrase adds value (read-only, auto-analysis disabled, canonical address, SHA-scoped project). 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?

Despite being a relatively simple read tool, the description lacks critical details for a tool with no output schema and no annotations. It does not describe what the returned metadata looks like, how parameters map to the schema, or how to handle the overlayId parameter. The description covers purpose and safety but not operability, making it 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 compensate, but it only alludes to runtimeAddress ('at one canonical NDS runtime address') and the project context ('already-current SHA-scoped project') without explicitly explaining each parameter. It does not clarify rom, processor, or the oddly-referenced overlayId, leaving significant gaps for parameter understanding.

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'), a specific resource ('Ghidra-derived function metadata'), and a precise scope ('at one canonical NDS runtime address from an already-current SHA-scoped project'). This clearly distinguishes it from sibling tools like nds_ghidra_decompile_function (which decompiles) or nds_ghidra_list_calls (which lists calls).

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

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

The description implies usage context: it reads function metadata from a current project and explicitly states it runs read-only with auto-analysis disabled, which hints at when it is safe to use. However, it does not explicitly name alternatives or exclusion criteria (e.g., 'use nds_ghidra_decompile_function for code'), so guidance is more implied 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?

With no annotations provided, the description carries the behavioral disclosure burden and mostly succeeds. It explicitly states the bounded depth-one traversal, the requirement of a canonical NDS function, the 'already-current project' precondition, and the absence of recursive traversal. This adds meaningful behavior context beyond the schema, though it omits return format and error 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 two sentences long, front-loaded with the primary action, and every clause adds meaningful constraint or context. There is no wasted or redundant prose.

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 seven parameters, no output schema, and no annotations. The description covers the tool's core purpose and limitations but omits parameter explanations, output/return behavior, expected error conditions, and practical usage context. For a tool of this complexity, the description is too sparse to be considered complete enough for an agent to use it correctly without additional guidance.

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 explain any of the seven parameters (rom, processor, runtimeAddress, direction, limit, offset, overlayId). The phrase 'one canonical NDS function' hints at runtimeAddress but provides no explicit mapping. The description adds almost no value in understanding parameter semantics.

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 ('List'), the resource ('callers/callees'), and the constraints ('bounded depth-one', 'Ghidra-derived', 'one canonical NDS function'). It distinguishes itself from sibling tools like nds_ghidra_list_references and nds_find_xrefs by specifying the graph traversal scope and derivation method.

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

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

The description implies when to use the tool: when you need direct, non-recursive callers/callees for a single function in a current project. The phrase 'No recursive graph traversal is exposed' provides an exclusion but does not name alternatives for recursive needs. It also mentions 'in an already-current project' as a prerequisite but does not explain how to ensure currency (e.g., via nds_ghidra_bootstrap).

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

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

With no annotations, the description carries the full burden and does disclose several behavioral traits: the data source (Ghidra), the bounded nature, the project-state prerequisite, and the non-authoritative caveat. However, it leaves out return behavior (e.g., empty results, error conditions) and the practical implication of non-authoritative data, which is a gap.

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

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

The description is two sentences, each earning its place. The first conveys the core action and scope; the second adds a critical caveat. It is front-loaded, specific, and free of padding.

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

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

Despite a clear core purpose, the description lacks essential details for a 7-parameter tool with no output schema and no parameter descriptions. It does not explain return format, the differences from similar sibling tools, or how to interpret the non-authoritative references, leaving significant gaps for an agent to invoke it correctly.

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

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

The schema has 0% description coverage for its 7 parameters, so the description must compensate. It only hints at 'bounded' (limit/offset) and 'to/from' (direction), while leaving rom, processor, overlayId, and the exact meaning of 'canonical NDS address' unexplained. This is insufficient for an agent to set all parameters correctly.

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

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

The description clearly states the tool's function: list bounded Ghidra-derived references to/from one canonical NDS address. It distinguishes itself from sibling tools like nds_list_references and nds_find_xrefs by emphasizing the Ghidra derivation, the pagination, and the single-address 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 clearly implies when to use this tool (when Ghidra-derived references are needed) and emphasizes that the project must be 'already-current.' It also warns that references are non-authoritative, which signals caution, but it does not explicitly point to alternative tools 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?

Without annotations, the description carries the transparency burden. It discloses that only bounded exact/prefix/contains matching is allowed and explicitly rejects regex/arbitrary queries, which adds behavioral context beyond the schema. However, it does not explicitly state that the operation is read-only or free of side effects, though 'search' implies this.

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

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

The description is two concise sentences with no filler. It front-loads the action and resource, then clarifies matching modes and exclusions, making every word earn its place.

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

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

Given the tool has 6 parameters, no annotations, and no output schema, the description provides essential context but remains minimal. It clarifies purpose, scope, and matching constraints, but omits details about return values, pagination (limit/offset) behavior, and explicit read-only confirmation, leaving some gaps for a tool of this complexity.

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

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

Schema description coverage is 0%, but the description compensates partially by explaining 'bounded exact, prefix, or contains matching' (mapping to match/limit) and 'one canonical ARM9 or ARM7 program' (mapping to processor). It does not detail the 'rom' parameter or query format constraints beyond 'no regex', leaving gaps in parameter understanding.

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 'Search' and the resource 'Ghidra/analyst symbols', specifying the scope as 'one canonical ARM9 or ARM7 program'. It also distinguishes the tool from sibling search tools like nds_search_pattern by emphasizing symbol lookup and exact/prefix/contains matching.

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 searching symbol names within a single program, and it sets clear constraints (no regex, exact/prefix/contains). However, it does not explicitly mention when to use this tool instead of alternatives such as nds_search_pattern or nds_ghidra_list_references, nor does it provide exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the operation is read-only ('without invoking Ghidra or mutating files'), deterministic, and SHA-scoped. This goes beyond a generic status description, offering meaningful safety and scoping context.

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

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

A single, well-structured sentence front-loads the verb 'Read' and packs key qualifiers (deterministic, SHA-scoped, without invoking Ghidra, without mutating files) with no filler. Every phrase adds value.

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

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

For a simple one-parameter status read, the description is mostly adequate, but it lacks detail on what 'Ghidra bridge/project state' actually includes and does not differentiate from get_project_status. With no output schema, the ambiguity about return fields is a noticeable 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 the description does not explain the 'rom' parameter beyond implying a ROM path or hash. While the parameter is somewhat self-explanatory, the description fails to compensate for the lack of schema documentation, leaving format and canonicalization 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 uses a specific verb 'Read' and a clear resource: 'SHA-scoped Ghidra bridge/project state' for a canonical Nintendo DS ROM. This distinguishes it from sibling tools like nds_ghidra_decompile_function or get_project_status by emphasizing it's a state read without invoking Ghidra.

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 a side-effect-free status check is needed, but it does not explicitly state when to use this tool versus alternatives like get_project_status or nds_ghidra_bootstrap. No exclusions or alternative references 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?

With no annotations, the description carries the full burden and explicitly states 'without modifying it', which is a critical non-destructive safety property. While it does not detail return format or error behavior, the main side-effect concern is covered.

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 entire description is one concise sentence that front-loads the main action and safety property. There is no fluff or repetition, and every word contributes to understanding the tool's purpose.

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

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

For a single-parameter tool with no annotations or output schema, the description covers the core purpose and non-modifying behavior, but omits details about the content of the structure summary, return format, prerequisites, or edge cases. It is adequate but leaves clear gaps for an agent.

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 'rom' is documented only by its schema type (string). Schema description coverage is 0%, and the description does not explain how the ROM should be provided (path, format, etc.). The name is self-evident, but the description fails to compensate for 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 clearly states the action (parse), target (Nintendo DS ROM), and output (canonical static structure summary). This distinguishes it from sibling tools like nds_list_files or nds_resolve_rom_offset, which focus on specific aspects rather than the entire structure.

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 use when a static structure summary is needed, but gives no explicit when-to-use versus alternatives, nor exclusions. Sibling tools exist for listing files or overlays, yet no guidance is provided for choosing this tool over them.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It indicates a read-only action through 'List' and hints at pagination via 'bounded,' but does not explain limitations, ordering, or potential errors. This is acceptable for a simple list operation but leaves room for more 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 concise sentence, front-loaded with the core action and resource. It is appropriately sized with no filler, though it omits important parameter information that could be integrated without bloating the 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?

Given the tool has four parameters (one required), pagination controls, and no output schema or annotations, the description is far too sparse. It does not cover return values, parameter behavior, or use cases, making it insufficient for an agent to use confidently.

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 makes no mention of the 'rom', 'limit', 'offset', or 'prefix' parameters. The word 'bounded' vaguely suggests limit/offset but does not explain their semantics. The description adds almost no value for understanding how to populate the 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 clearly states 'List bounded NitroFS/FAT file mappings from the canonical NDS model,' providing a specific verb and resource. It distinguishes itself from siblings like nds_list_overlays by naming a distinct resource type (file mappings vs overlays), but does not explicitly call out alternatives.

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 such as nds_list_overlays or nds_inspect_rom. The description merely states what it does without any contextual conditions or exclusion criteria.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It does add value by stating that it does not claim runtime loaded state, which is a useful caveat. However, it does not mention that the operation is read-only, what happens with invalid input, or the nature of the returned metadata, leaving significant behavioral ambiguity.

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 fluff. The verb and key qualifiers are front-loaded, and every word contributes to the meaning. It is appropriately sized for the information it conveys.

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 no annotations and no output schema, so the description should provide more context. It does not explain what fields are in the metadata, how limit/offset work, or whether a valid ROM is required. For a list operation, this leaves too many unanswered questions for an agent to use it confidently.

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 by explaining parameters. It only implies the processor parameter via 'ARM9/ARM7', but leaves 'rom', 'limit', and 'offset' completely unexplained. This is insufficient for a tool with four 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 clearly states the action ('List') and resource ('bounded ARM9/ARM7 overlay metadata'), and adds a scoping phrase ('without claiming runtime loaded state') that distinguishes it from tools that might report loaded state. However, it does not explicitly differentiate from siblings like nds_list_files or nds_inspect_rom, which slightly lowers the score.

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

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

No guidance is provided on when to use this tool versus alternatives. The phrase 'without claiming runtime loaded state' is a behavioral qualifier, not a usage directive. The description does not mention exclusions, prerequisites, or contexts where another 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?

With no annotations, the description carries the transparency burden. It discloses that results are 'bounded', 'deterministic', and 'proven', hinting at safe/static behavior, but it does not explain what 'proven' means in practice, whether the operation is read-only, or what happens if the code window is not uniquely mapped. Partial disclosure.

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

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

The description is a single sentence, front-loaded with the verb and resource, and has no wasted words. It is concise but the dense jargon ('bounded deterministic proven', 'uniquely mapped') sacrifices immediate comprehension.

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 8 parameters, no output schema, and no annotations, yet the description is only a vague one-liner. It does not explain how to specify the code window, what the return value represents, or how parameters interact. This is severely incomplete for a tool with this complexity.

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

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

The schema has zero description coverage for its 8 parameters, and the description does not define any of them. Terms like 'code window' are not mapped to the actual parameters (rom, processor, mode, maxBytes, overlayId, romOffset, runtimeAddress, maxInstructions), so the description adds no value in understanding the input semantics.

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 verb 'List' and the resource 'references' are clear, and the phrase 'from one uniquely mapped code window' indicates a scope. However, 'references' is ambiguous—it is not specified whether these are cross-references, data references, or branch targets—and the description does not distinguish this tool from the sibling nds_find_xrefs.

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. The description does not mention any prerequisites, exclusions, or alternative tools. The 'uniquely mapped code window' hint implies a constraint but stops short of stating when this tool is the right choice.

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

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

With no annotations, the description must disclose behavioral traits. It mentions 'verified' and 'controlled' but does not explain side effects, permissions, or what happens to the input ROM or filesystem. For a build/mutation tool, this leaves significant behavioral ambiguity.

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

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

A single, front-loaded sentence conveys purpose, constraints, and method without waste. Every phrase adds meaning.

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 a mutation builder without annotations or output schema. The description omits prerequisites, meaning of 'verified', and implications of the mutation process, making it incomplete for an agent to safely invoke without further context.

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

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

Schema coverage is 0%, so the description must compensate. It hints at the 'manifest' parameter via 'strict workspace manifest' and possibly 'rom' via 'staged source copy', but does not explicitly map or explain either parameter. Both parameters are required and remain under-explained.

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 ('build') and identifies the resource ('NDS mutation') from a source ('strict workspace manifest', 'controlled staged source copy'). It clearly distinguishes this tool from sibling validation/verification tools like nds_mutation_validate and nds_mutation_verify.

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: building a mutation from a strict workspace manifest using a staged copy. However, it does not explicitly state when not to use it or name alternatives, though the workflow implication is strong.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It explicitly states that the tool does not modify or publish anything, which is a critical safety guarantee. However, it does not describe the return value, error behavior, or what happens on validation failure, so it is not fully transparent.

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

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

The description is a single, well-structured sentence that is immediately understandable. Every word adds value: 'strict', 'workspace-contained', 'exact source ROM', and 'without modifying or publishing anything' all convey important nuances without fluff.

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 that this is a validation tool with no output schema and no annotations, the description covers the core purpose and safety behavior, but it omits expected return values, success/failure cues, or potential side effects beyond 'no modification'. For an agent to effectively use the output, this is a notable 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?

The input schema only provides parameter names (rom, manifest) with no descriptions, giving 0% schema coverage. The description subtly defines 'rom' as the exact source ROM and 'manifest' as the mutation manifest, but it does not explain their format, constraints, or how 'strict' validation works. It partially compensates for the lack of schema descriptions but not fully.

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

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

The description clearly states the action ('Validate') and the specific resource ('strict workspace-contained NDS mutation manifest against the exact source ROM'). It also distinguishes this from sibling tools like nds_mutation_verify by emphasizing the strict containment and exactness, and explicitly notes that nothing is modified or published.

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

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

The description implies this is a dry-run validation step before building or publishing, but it does not explicitly say when to use this tool instead of nds_mutation_verify or nds_mutation_build. The 'without modifying or publishing anything' hint provides some context, but there is no direct guidance on choosing this over 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It does not mention whether the operation is read-only, has side effects, requires specific permissions, or describes failure outcomes. The word 'revalidate' implies verification but adds no concrete behavioral 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, focused sentence with no filler, putting the verb 'revalidate' up front. It is appropriately concise, though the heavy use of domain jargon (e.g., 'deterministic NDS mutation build') may obscure clarity for agents unfamiliar with the domain.

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

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

Given there is no output schema or annotations, the description should at least hint at return values or success/failure criteria, but it does not. It also fails to explain the relationship with sibling tools like nds_mutation_build and nds_mutation_validate, leaving the tool's role in the broader workflow unclear.

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 description coverage is 0%, so the description must compensate. It mentions 'workspace manifest' but does not explain the 'rom' parameter or how the two parameters relate. No format, constraints, or role of each parameter is described, leaving the agent to infer meaning from parameter names alone.

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 'revalidate' and identifies the resource as 'the exact deterministic NDS mutation build derived from a strict workspace manifest', which clearly states its purpose. However, it does not explicitly distinguish from sibling tools like nds_mutation_validate, so it is clear but not fully differentiated.

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 explicit guidance is provided on when to use this tool vs alternatives such as nds_mutation_validate or nds_mutation_build. The phrase 'freshly revalidate' hints at a re-check use case but does not offer exclusions or mention alternative tools, leaving the agent without clear selection criteria.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates an analysis operation via 'Classify', suggesting it is non-destructive, but does not disclose output format, potential errors, side effects, or any constraints. This is minimal transparency for an unannotated tool.

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 that front-loads the purpose and scope without any fluff. Every word contributes to conveying the tool's function.

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

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

Given the tool has two parameters, no annotations, and no output schema, the description is incomplete. It fails to explain the expected return value, the meaning of 'relationships', or any usage context. The description is a minimal stub that does not provide enough guidance for an agent to confidently invoke it.

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 2 parameters with 0% schema description coverage, and the description does not describe either parameter in detail. It does imply that 'offset' refers to a ROM offset, but it does not clarify the 'rom' parameter or parameter relationships. The description adds only a minimal hint beyond the raw schema.

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

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

The description uses a specific verb 'Classify' and a specific resource 'one ROM offset', making the tool's purpose clear. It further distinguishes itself from sibling tools like nds_resolve_runtime_address by specifying the classification scope across NDS structural, file, main-binary, and overlay relationships.

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 classifying ROM offsets within NDS contexts, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. No alternative tools are named, and no when/when-not guidance is provided, so it only hints at usage 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?

With no annotations, the description carries full burden for behavioral disclosure. It mentions one trait ('without guessing overlap state') but fails to state whether the operation is read-only, what happens on failure, or any side effects. The phrase is cryptic and not fully explained.

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 is succinct and front-loaded with the core action. It contains no filler and earns its place, though it may be too brief for complete 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?

Given no output schema and no annotations, the description should explain return values and error behavior. It does not mention what the resolved output looks like, whether it can fail, or any prerequisites (e.g., ROM must be loaded). This is a significant gap for programmatic invocation.

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

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

The description clarifies that 'address' refers to a runtime address and 'processor' is ARM9/ARM7, and that resolution involves main code and overlays (implying the 'rom' parameter provides these). However, the 'rom' parameter itself is not explicitly described, and with 0% schema coverage, more explanation is needed to fully compensate.

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 'resolve' and clearly states the resource: an ARM9/ARM7 runtime address, against main code and static overlay candidates. This distinguishes it from sibling tool 'nds_resolve_rom_offset', which likely handles ROM offsets rather than runtime addresses.

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

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

The description gives clear context on what the tool does (resolving runtime addresses against code and overlays) and the constraint 'without guessing overlap state' suggests it avoids ambiguity. However, it does not explicitly name alternatives or state when not to use it, so it lacks explicit 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?

With no annotations provided, the description carries full behavioral burden. It discloses that the operation does not mutate or use heuristic inference, but it does not explain what the search returns, how matches are presented, or the meaning of parameters like limit, offset, and maxScanBytes. It also leaves the 'validated ROM' prerequisite ambiguous, not stating whether the tool validates internally or requires pre-validation.

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

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

The description is a single, well-structured sentence with no redundant words. It front-loads the action and resource, then lists the accepted pattern types and the non-mutating nature, all in one compact statement.

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

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

Given no output schema and no annotations, the description should provide a richer overview of the tool's behavior and results. It omits information about search scope selection, result format, pagination, and the significance of validation. The complex nested schema and seven parameters demand more explanatory context than this one-sentence description offers.

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 all seven parameters. It does clarify the 'pattern' parameter by listing its supported types, but it provides no explanation for the 'scope' variants, 'limit', 'offset', 'contextBytes', or 'maxScanBytes'. This is insufficient for a schema with nested objects and no property descriptions.

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 ('Search') and a specific resource ('validated Nintendo DS ROM'), and enumerates pattern types ('byte signature, typed integer, ASCII string, or UTF-16LE string'). It also differentiates the tool from mutation-related siblings by explicitly stating 'without mutation or heuristic inference'.

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 read-only search usage but does not explicitly state when to use this tool vs alternatives like nds_find_xrefs or nds_disassemble_range. The phrase 'without mutation' hints at a safe context, but there is no direct exclusion or mention of sibling tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It usefully discloses that only allowlisted npm scripts can be run and that arbitrary commands are rejected, which is important safety-relevant behavior. However, it does not mention whether the script may modify files, what output or exit codes are returned, or any permission/prerequisite requirements, leaving notable transparency gaps for an execution tool.

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