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

The description adds useful behavior beyond the readOnlyHint annotation by noting 'if any,' which signals that a null/empty result is possible when no program is running. It does not contradict the annotations, and the read-only nature is reinforced by 'Report.'

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, direct sentence that front-loads the core action and resource. Every word earns its place, with no filler or redundant restatement of the tool name.

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

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

For a simple, read-only, zero-parameter status query, the description is complete. It tells the agent what is reported, the file type, and the 'if any' absence case, which is enough to invoke the tool correctly without an output schema.

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

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

The tool has zero parameters and the schema reflects that with an empty properties object, so schema coverage is complete. No parameter explanation is needed, and the baseline for a zero-parameter tool applies.

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

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

The description clearly states a specific action ('Report') and resource ('the currently running .rxe program'), and the 'currently running' qualifier distinguishes it from sibling tools like start_program and stop_program. The extension '.rxe' adds concrete specificity.

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 'currently running' gives clear context for when to use this tool: when an agent needs to know what program is active. It does not explicitly name alternatives or provide when-not guidance, but no close sibling offers the same purpose, so the context is sufficient without exclusions.

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

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

Annotations provide little value with all hints false, so the description carries the burden. It does disclose the motor cycling behavior and the success beep, which goes beyond the schema. However, it omits important behavioral details such as failure handling, timeout behavior, and blocking 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?

A single 12-word sentence that front-loads the core action and ends with the outcome. Every word earns its place, and there is no redundant repetition of schema information.

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

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

For an 8-parameter tool with no output schema, no parameter descriptions, and a large sibling set, this description is too thin. It lacks parameter semantics, usage context, and behavioral detail needed for correct invocation, especially without any annotation support.

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 alludes to 'touch' and 'beep', giving hints about touch_port and beep-related parameters, but it does not explain cycles, forward_power, max_ticks_per_phase, timeout_seconds_per_phase, or how these parameters interact.

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 ('Cycle') and a clear resource ('a motor') with a distinctive behavior ('between touch press/release phases, then beep on success'). It conveys the tool's core function well enough to distinguish it from generic run/move siblings, though it does not explicitly name any sibling.

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

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

No guidance is provided about when to use this tool versus alternatives like run_motor_until_sensor or run_motor. The description states what the tool does but not the conditions, prerequisites, or scenarios where it should be preferred, leaving the agent to infer applicability.

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 says 'Delete,' which is a destructive action, but the annotations set destructiveHint to false. This is a direct contradiction. The description also does not mention irreversibility, permissions, or side effects beyond the deletion itself.

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

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

The description is one short, front-loaded sentence with no filler. It is efficient, though its brevity omits important behavioral and usage context that would make it fully helpful.

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

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

For a destructive file operation with no output schema, the description should disclose irreversibility and failure behavior. The contradictory destructiveHint makes the tool's safety profile unclear, and while the single-parameter complexity is low, the missing context is still significant.

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 says 'NXT user-flash file' to hint at what name refers to. It does not specify whether name requires an extension, a path, or any formatting constraints, leaving the only parameter underspecified.

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

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

The description states a specific verb and resource: 'Delete one NXT user-flash file.' This clearly distinguishes the tool from siblings like read_file, write_file, and list_files.

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

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

No guidance is provided about when to use this tool versus alternatives, nor any exclusions or prerequisites. The description does not mention checking file existence with list_files or any conditions under which deletion should be avoided.

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

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

Annotations are all false and do not convey behavior, so the description carries the full burden. It reveals that the synchronization is firmware-level, but it does not say whether the call blocks, how long motors run, whether they continue until stopped, or how to stop them. For a start-style action with no output schema, 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 front-loaded sentence with no filler and starts with the action verb. It is highly concise, although the brevity contributes to missing behavioral and parameter detail, which is penalized in other dimensions.

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 four parameters, 0% schema description coverage, no output schema, and annotations that do not describe runtime behavior, one phrase is not enough for correct invocation. The description omits termination behavior, return/acknowledgment behavior, prerequisites, and turn_ratio semantics, and it does not connect to relevant siblings like stop_motors or emergency_stop.

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 needed to compensate. It clarifies that left_port and right_port are the two motors of the pair, but it does not explain the meaning, range, or units of power, nor the semantics of turn_ratio, including sign, scale, or default behavior. The description adds little beyond the bare parameter names.

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 gives a specific verb, 'Start', and a specific resource, 'firmware-synchronised two-motor drive pair'. The 'firmware-synchronised' modifier distinguishes this from general motor siblings like run_motors or move_motors, so an agent can identify the unique purpose.

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

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

Usage is implied rather than stated: the description suggests using this when a synchronized two-motor drive is needed, but it does not give explicit when-to-use or when-not-to-use conditions, nor does it name alternatives. There is no exclusion guidance compared to other motor 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?

Annotations already mark this as non-readonly, idempotent, and non-destructive. The description adds useful behavioral details beyond those flags: motors are coasted (not actively braked) and the action is immediate. It does not contradict the annotations.

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

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

Six words in one sentence with no filler; the key action and scope are front-loaded. Every word earns its place.

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

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

For a no-argument command with no output schema, the description covers the necessary information: the action (coast), immediacy, and scope. It leaves out explicit guidance about post-state or program status, but annotations cover idempotence/safety and the action is fully specified.

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

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

The tool has zero parameters and schema coverage is 100%, so there is nothing for the description to add about argument semantics. The 'all three output ports' phrase clarifies the implicit target, satisfying the baseline for a no-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 uses a specific verb ('coast') and resource ('all three output ports'), making the tool's function unambiguous. It clearly differentiates itself from siblings like stop_motor/stop_motors by specifying the coast action and the all-ports 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 an emergency/all-ports stopping context with 'Immediately' and 'all three,' but it does not explicitly state when to choose this over stop_motor/stop_motors/stop_program or mention exclusions. Usage is therefore 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?

Annotations already convey that the tool is read-only and non-destructive (readOnlyHint=true, destructiveHint=false), so the safety profile is covered. The description adds that the tool returns the source of a saved behavior, which is mildly informative, but it does not disclose what happens when the named behavior does not exist or what form the returned source takes. This is acceptable given the read-only annotation but not deeply 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 short sentence with no filler or redundancy. It is front-loaded with the action and resource, making it easy for an agent to parse quickly.

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

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

For a simple one-parameter read-only tool, the description is mostly sufficient: it states the input and what is returned. However, with no output schema, the description could clarify the format or nature of the returned source, and could mention the behavior-not-found case. It is adequate but not complete.

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

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

The schema has zero description coverage for the required 'name' parameter. The description only says 'a saved behavior' without explicitly connecting the 'name' parameter to the behavior identifier, though that connection is reasonably inferable. The tool's single parameter is simple, but the description does not fully compensate for the absence of schema-level parameter 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 uses a specific verb ('Return') and names a concrete resource ('the source of a saved behavior'), which clearly identifies the tool's function. It distinguishes itself from sibling tools like run_behavior and list_behaviors by focusing on retrieving source rather than executing or listing behaviors. However, 'source' could be more explicitly defined, and the description does not explicitly contrast it with siblings.

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

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

The description gives no guidance on when to use this tool versus alternatives. There is no mention of list_behaviors for enumerating behaviors, run_behavior for executing one, or validate_behavior for checking one. The agent must infer usage entirely from the tool name and sibling list.

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

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

'Bounded' and 'opt-in' add some behavioral context beyond the annotations, hinting at time limits and explicit user initiation. However, the description does not disclose whether the transaction sends bytes, reads bytes, blocks, fails on timeout, or has any side effects on the I2C bus. It is not contradictory to the annotations, but it is thin.

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 is concise, though the brevity comes at the cost of important operational details.

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 four parameters, no output schema, and no useful behavioral annotations, the description is far too minimal for an agent to invoke the tool correctly. It lacks return-value expectations, I2C addressing details, timeout behavior, and any error or failure semantics, leaving significant gaps.

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

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

Schema description coverage is 0%, so the description should compensate for unclear parameters, but it does not mention port, write_bytes, read_length, or timeout_seconds. The schema titles are somewhat self-explanatory, but exact byte encoding, valid ranges, and the role of read_length are left unexplained.

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

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

The description states a specific action: 'Perform one bounded opt-in NXT low-speed/I2C transaction.' This clearly identifies the resource (I2C transaction) and scope (one bounded transaction), and no sibling tool obviously targets I2C, so it is distinguishable enough. It slightly loses a point for not explicitly differentiating from sibling communication tools like mailbox_send or read_sensor.

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 offers no guidance about when to use this tool versus alternatives, no exclusions, and no context about interacting with an NXT I2C device. The phrase 'one bounded... transaction' weakly implies a single-shot operation, but there is no explicit call to action or comparison to other 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?

Annotations provide no hints (all false), so the description carries the burden. It correctly discloses that the tool performs a reset (a mutation, consistent with readOnlyHint=false) and reports the timeout. However, it does not explain side effects, whether it is safe during program execution, or what happens if the standby timer is unavailable — leaving some 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, tightly worded sentence places the primary action first and avoids any filler or repetition. Every part of the description earns its place.

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

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

For a zero-parameter tool with no output schema, the description covers the core action and the nature of the return value ('report its configured timeout'). It is slightly thin on usage context and output format, but adequate for a simple call.

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 there is nothing for the description to explain beyond what the schema shows. Baseline for 0 params is 4, and the description does not need to add parameter detail.

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 'Reset' and identifies the exact resource ('stock firmware standby timer'), plus a second clear action ('report its configured timeout'). This unambiguously distinguishes the tool from all sibling tools, none of which mention standby timers or keep-alive logic.

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 — to prevent standby by resetting the timer — but gives no explicit context about when to invoke it, when not to, or how it relates to alternatives. There is no mention of operational scenarios or conditions that would make this tool preferable to others.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context by specifying 'PC-side' and 'Python behaviors,' but it does not disclose return format, ordering, or whether the list is empty-safe. This is adequate for a simple read-only list tool but adds no behavioral depth beyond the annotations.

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

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

A single, directly worded sentence carries the entire description with zero wasted words. The key terms 'List' and 'saved PC-side Python behaviors' are front-loaded and unambiguous.

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

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

For a parameterless read-only list tool, the description is sufficiently complete. The mention of 'PC-side' clarifies scope relative to brick-local behaviors, and no output schema exists to require return-value documentation. Minor missing context, such as what fields each listed behavior includes, prevents a perfect score.

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

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

The tool has zero parameters and the schema is empty, so there is nothing for the description to add about parameter semantics. With 0 params, the baseline is 4, and the description fully covers the absence of inputs.

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

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

The description states the specific verb 'list' and the resource 'saved PC-side Python behaviors,' making the tool's function immediately clear. It also distinguishes itself from sibling tools like get_behavior (retrieve one) and run_behavior (execute).

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 'saved PC-side Python behaviors' implies when to use the tool: when an agent needs to enumerate saved behaviors. However, it does not explicitly contrast with alternatives like get_behavior for retrieving a single behavior or run_behavior for executing one, so the usage guidance remains implicit rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the location detail 'NXT user flash' but does not disclose how the optional pattern affects results or whether the listing is recursive or sorted.

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 and is easy to parse. However, the brevity leaves out useful parameter and usage context, so it is concise but slightly under-specified.

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

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

For a simple read-only listing operation with annotations covering safety and no output schema, the description provides a workable baseline. The absence of pattern semantics and result behavior keeps it from being fully complete.

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

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

The sole parameter 'pattern' has 0% schema coverage, and the description does not mention it at all. The default '*.*' hints at glob-style filtering, but the agent must guess the syntax and scope of the pattern.

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

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

The description states a specific verb ('List') and resource ('files stored in NXT user flash'), making the tool's purpose clear. It is distinguishable from sibling file tools like read_file, write_file, and delete_file, though it does not explicitly name those 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 for when to use this tool versus related file operations. The only implied signal is that it lists stored files, but there is no mention of filtering, alternatives, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the 'completed or active' scope and CSV output format, but does not disclose how the export is delivered, whether a file is created, or how results are returned.

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

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

The description is a single, well-structured sentence with no filler. Every word contributes to understanding the tool's function and scope.

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 and annotations cover safety, but there is no output schema and the description does not explain the return value or export mechanism. An agent would understand the purpose but not know what to do with the output or how job_id is obtained.

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 clarifies the output format 'CSV', which maps to the format parameter, but it does not explain what job_id refers to, where it comes from, or how it relates to the logging lifecycle.

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 specifies an exact verb ('Export'), a resource ('telemetry samples'), a format ('CSV'), and a scope ('completed or active'). This makes it clearly distinct from sibling logging tools like log_start, log_status, and log_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?

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites like having an active or completed job from log_start. The description states what the tool does but not the conditions under which it should be invoked.

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 word 'bounded' adds useful behavioral context beyond the annotations, implying the log job has a finite duration. However, the description does not clarify side effects such as whether a new job replaces an existing one, whether telemetry accumulates, or how stopping/exporting relates to this job.

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 sentence contains the core action and key qualifiers with no filler. It is front-loaded and appropriately sized for the tool's apparent simplicity.

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, minimal annotations, and zero parameter descriptions, the description is too sparse to fully support correct invocation. An agent would still not know what values channels should contain or how interval_ms and duration_seconds relate to the bounded job.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters, but it does not mention channels, interval_ms, or duration_seconds at all. The term 'bounded' hints at duration but is insufficient for understanding the required 'channels' parameter.

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

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

The description uses a specific verb ('Start') and a specific resource ('bounded host-side telemetry log job'), clearly distinguishing this from siblings like log_status, log_stop, and log_export. It communicates both the action and the scope of the operation.

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 about when to use this tool versus related siblings such as log_status, log_stop, or log_export. An agent must infer that starting a log is the initial step; no exclusions, prerequisites, or alternatives are mentioned.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe-read nature is covered. The description adds that the tool exposes state and sample count, which is helpful, but it does not explain behavior for invalid job IDs, empty telemetry data, or whether the job must be active.

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

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

The description is a single concise sentence with no filler. The primary action and resource are front-loaded, making it easy to scan.

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

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

The tool is simple and the annotations cover its safety profile, but there is no output schema and the description does not describe the return shape beyond 'state and sample count.' Job ID semantics are also left undocumented, so an agent may need to infer how to obtain the ID.

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

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

Schema description coverage is 0%, and the description only says 'telemetry job' in relation to job_id. It does not explain where the job_id comes from, what format it uses, or how to obtain it from log_start. The schema alone provides only the parameter name and type.

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

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

The description names a specific verb ('Read') and a clear resource ('state and sample count of a telemetry job'). This clearly distinguishes it from log_start, log_stop, and log_export, which are the most closely related siblings.

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

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

The read-oriented wording makes the intended use reasonably obvious, but the description does not explicitly state when to use this tool versus log_start, log_stop, or log_export. There are no exclusions or alternative routing hints provided.

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

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

Annotations already indicate that this is not read-only, not idempotent, and not destructive. The description adds modest behavioral context by framing the operation as a 'request' to stop, implying possible asynchronicity, but it does not disclose side effects, error behavior, or what happens if the job is already stopped.

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 communicates the action and the resource efficiently.

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

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

For a simple one-parameter tool with no output schema, the description is mostly complete: it names the action, the resource, and the request nature. Missing details such as expected return behavior and valid job_id sources are minor given the tool's simplicity.

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

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

The schema describes job_id only as a required string, and description coverage is 0%. The description adds meaning by clarifying that the job is a 'telemetry job,' which ties the parameter to the tool's domain, though it does not explain how to obtain a valid job_id or what values are expected.

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 ('stop') and a specific resource ('a telemetry job'), which clearly distinguishes it from siblings like log_start, log_status, and log_export. Even without the title, the agent knows exactly what this tool does.

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 log_start, log_status, or log_export. The relationship to log_start is implied by the name, but the description itself provides no explicit contextual or exclusionary guidance.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, but the schema contains a 'remove' boolean defaulting to true, suggesting the tool may consume or delete the message. The description does not disclose this side effect or explain waiting/blocking behavior for an empty mailbox. The safety annotations provide some context, but the most important behavioral nuance 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, front-loaded sentence with no filler. It is concise, though somewhat under-sized given the behavioral details that need to be covered; it earns points for efficiency but not for completeness.

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

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

There is no output schema and the description does not explain return values, empty-mailbox behavior, blocking semantics, or the default removal side effect. For a tool with one required parameter and a behavioral switch, this leaves too much for the agent to guess.

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 either parameter. An agent can infer that 'inbox' identifies the mailbox, but the meaning of 'remove' — whether the message is deleted after retrieval and that it defaults to true — is entirely undocumented. The description does not compensate for the schema gap.

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

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

The description states a specific verb and resource: 'Receive one NXT mailbox message.' This clearly identifies the operation and is distinguishable from the sibling mailbox_send. It could be stronger by explicitly naming the inbox/source, but the core purpose is unambiguous.

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

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

The intended use is implied by the verb 'receive': an agent would use this when it needs to retrieve a mailbox message. However, the description gives no explicit guidance about when not to use it, does not reference mailbox_send as the alternative, and does not mention conditions such as handling an empty mailbox.

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?

All annotations are false, so the description carries the burden of behavioral disclosure. It adds useful context by stating the message must be 'bounded UTF-8', but it does not explain what the bound is, side effects on the inbox, or failure modes. Some behavioral context is present, but significant 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 seven-word sentence with no wasted words. The core action, target, and constraint are all front-loaded, and every word contributes meaning. Appropriate for a simple two-parameter tool.

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

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

For a simple tool with no output schema, the description covers the essential operation and encoding constraint, but leaves 'bounded' undefined and provides no information about error conditions or acceptable inbox values. The sibling mailbox_receive is not referenced, so the description is insufficient to fully contextualize behavior.

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

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

With 0% schema description coverage, the description must compensate. It indirectly clarifies that 'data' is the UTF-8 message content (and is bounded) and that 'inbox' is the mailbox destination. However, it does not directly map parameters, explain the integer inbox range, or define the bound size, leaving ambiguity.

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 'Send' with a clear resource 'NXT mailbox message' and adds a meaningful constraint 'bounded UTF-8'. It clearly distinguishes itself from the sibling tool mailbox_receive, which performs the opposite operation.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. Although mailbox_receive is present in the sibling list, the description never mentions it or any circumstances that would select one over the other. Usage is only implied by the verb 'Send'.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false. The description adds meaningful context beyond that by specifying that the tool returns both absolute and raw encoder positions in degrees, giving an agent useful expectations about the result. It does not go into failure modes, but for a simple read tool that is a minor 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?

A single sentence conveys the purpose, resource, and units with no unnecessary words. The information is front-loaded 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?

For a simple one-parameter read-only tool, the description is complete: it states what is read and the units of the result, annotations cover the safety profile, and the schema clarifies the required port. No critical invocation detail is missing.

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

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

Schema description coverage is 0%, and the description does not mention the required 'port' parameter at all. The schema's enum and title make the parameter reasonably self-explanatory, but the description itself contributes no parameter-level guidance, so it does not 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 names the exact action ('Read') and resource ('a motor's absolute and raw encoder positions') with units ('degrees'). This clearly differentiates it from siblings like zero_motor_position or run_motor, which imply different operations.

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

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

The description implies it should be used when a motor's position values are needed, which is clear enough at a basic level. However, it does not explicitly contrast with sibling tools like motor_state or read_sensor, nor does it state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds 'detailed' but doesn't specify what state variables are returned, error behavior, or side effects. With annotations present, a 3 is appropriate for limited added 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?

One short, front-loaded sentence with zero redundancy. Every word earns its place.

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

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

The tool is simple (1 param, no output schema), but 'detailed observable state' is vague – an agent doesn't know what fields to expect. Sibling tools like motor_position give a hint, but the description doesn't enumerate state dimensions. It's adequate for basic use but lacks specificity.

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 has 0% description coverage, but the single parameter 'port' is fully defined by its enum (A/B/C). The description doesn't add parameter-specific meaning, but the schema makes the parameter clear. It doesn't compensate beyond what the schema provides, so a baseline 3 is fair.

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

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

Description states 'Read detailed observable state for one motor' – a specific verb, resource, and scope. It clearly distinguishes from siblings like motor_position (which likely gives only position) and motor control tools. The adjective 'detailed' differentiates it as a more comprehensive read.

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 when-to-use or when-not-to-use guidance. 'Detailed' implies it's for fuller state vs. motor_position, but the description doesn't name alternatives or conditions. Usage is implied but not stated.

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

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

The description discloses that the motor moves to an absolute position referenced to its last zero, which is useful behavioral context beyond the annotations. However, it does not mention whether the command blocks until the position is reached, how brake/power/timeout affect the movement, or what happens if no zero has been set.

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 action and scope. It contains no filler or redundant restatement of the tool name.

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

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

With five parameters, no output schema, and no parameter descriptions, this minimal description is not complete enough for an agent to invoke the tool confidently. Important contextual details such as blocking behavior, the need for a prior zero, how power/brake/timeout are applied, and the return value are missing.

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

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

Schema description coverage is 0%, so the description must compensate for all five parameters, but it only loosely maps to 'motor' (port) and 'absolute position' (target_degrees). The optional parameters brake, power, and timeout_seconds are not explained at all, leaving their semantics entirely to the schema titles and defaults.

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 ('Move') and names the exact resource ('one motor') and the mode ('absolute position relative to its last zero'). It distinguishes itself from the sibling tools move_motor_relative (relative movement) and move_motors_absolute (multiple motors) without extra detail.

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 'absolute position relative to its last zero' implies that the motor must have a previously established zero reference, and 'one motor' implies single-axis use. However, there is no explicit guidance about when to choose this tool over move_motor_relative or move_motors_absolute, nor any exclusions or prerequisites stated.

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

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

Annotations already indicate a non-read write operation and non-idempotence, and the description adds a 'then stop' behavior, which is useful. It does not disclose blocking behavior, brake semantics, timeout handling, or failure effects, so behavioral transparency is only partially addressed.

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

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

The description is a single efficient sentence that leads with the action verb and avoids filler. The unexplained 'bounded' term costs a point, but the structure is otherwise appropriately front-loaded and 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 five parameters, no output schema, and no parameter explanations, an agent would still need to infer how power, brake, timeout_seconds, and 'bounded' affect execution. The description covers only the core action and omits operational details necessary for reliable 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 by explaining parameters. It only clarifies 'degrees' as relative encoder degrees and loosely implies 'port' via 'one motor'; power, brake, and timeout_seconds receive no semantic explanation.

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

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

The description states a clear verb ('Rotate'), resource ('one motor'), and mode ('relative encoder degrees'), which distinguishes it from move_motor_absolute and the multi-motor sibling tools. However, 'bounded' is ambiguous and unexplained, so the purpose is not quite perfectly specified.

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 usage context: single-motor relative movement. It does not explicitly say when to use this tool instead of move_motor_absolute, move_motors_relative, or run_motor, nor does it state any exclusions or alternatives, so guidance is only implicit.

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

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

Annotations already provide readOnlyHint=false and destructiveHint=false, so the agent knows this is a mutating, non-destructive operation. The description adds the concurrent-execution trait, which is useful, but it does not disclose timeout handling, brake behavior, blocking semantics, or what happens if a motor fails partway.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the core action and distinguishing scope, making it 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?

For a tool with five parameters, three required, zero schema descriptions, and no output schema, this one-sentence description is underpowered. An agent still lacks critical invocation details such as how the ports/powers/target_degrees arrays must align, what units are expected, and what the tool returns or does on timeout, so the description is not complete enough for reliable use.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter meaning. It only faintly maps 'absolute positions' to target_degrees and 'several motors' to ports; it never clarifies array correspondence, power units, port enumeration, or timeout/brake effects. The property names are self-descriptive, but the description adds almost no semantic value beyond them.

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

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

The description uses a specific action ('Move') and resource ('several motors'), and the qualifier 'concurrently to independent absolute positions' clearly distinguishes it from singular or relative motion siblings like move_motor_absolute and move_motors_relative. An agent can tell what this tool does without opening the schema.

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: when multiple motors need to be moved at once to absolute positions. It does not explicitly state exclusions such as 'for a single motor use move_motor_absolute' or 'for relative motion use move_motors_relative,' but the phrasing implies the appropriate selection among the sibling tools.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, signaling a mutating operation without destruction. The description adds 'concurrently' and 'bounded degrees,' which clarifies execution semantics but does not explain what 'bounded' means (e.g., blocking until completion, timeout behavior) or what happens on error. It does not contradict annotations.

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

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

The description is a single, short sentence with no filler. It is front-loaded with the main verb and resource. However, it is so brief that it sacrifices necessary detail, so while it is concise, it borders on under-specification rather than elegant economy.

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, no parameter documentation in the schema, and a description that only states generic movement, this is inadequate for a tool with 5 parameters and 3 required. An agent cannot determine how powers, degrees, and ports correspond, how 'bounded' is enforced, or what the command returns or when it completes.

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 documenting parameters, but it does not explain any of them. It does not mention ports, powers, degrees, brake, or timeout_seconds, nor their relationships (e.g., parallel arrays). The term 'bounded degrees' hints at degrees but fails to clarify that degree values are relative or bounded.

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 ('move'), a specific resource ('motors'), and a key qualifier ('relative', 'concurrently', 'bounded degrees'). It clearly communicates the core action. However, it does not explicitly differentiate from siblings like move_motor_relative (singular) or move_motors_absolute beyond the word 'relative,' which is already in the name.

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 moving multiple motors concurrently, which distinguishes it from single-motor moves, but it does not explicitly state when to use it versus other motor control tools like run_motors, drive_sync, or move_motors_absolute. No alternatives or exclusions are mentioned.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the scope 'connected NXT' and the data categories returned, but it does not explain units, exact fields, or failure behavior. Annotations lower the bar, so a 3 is appropriate.

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

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

The description is a single sentence with no filler. It front-loads the action and resource, and every word contributes meaningful information.

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

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

For a trivial no-parameter read-only info tool, the description is mostly sufficient. It lists the three returned categories, though exact field names or units are not specified and there is no output schema to fill that gap. This is a minor omission rather than a major one.

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

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

The tool has zero parameters and schema description coverage is effectively 100%, so there is nothing for the description to add. The baseline for a zero-parameter tool is 4.

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

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

The description uses a specific verb ('Return') and names concrete resources: identity, battery, and free storage for the connected NXT. This is distinct from sibling tools like read_sensor, motor_state, and query_all_state, so the agent can tell what this tool is for.

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 such as query_all_state or read_sensor. The description implies a read-only device-information context, but it provides no exclusions, prerequisites, or explicit comparison to siblings.

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

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

Annotations are all false and provide no useful safety profile. The description only restates the basic play action and does not disclose whether playback blocks, repeats indefinitely with loop, or requires stop_sound to halt.

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 key action front-loaded. It is appropriately sized for a simple tool, though it omits important loop and stopping details.

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 sound-playing tool with no output schema and unhelpful annotations, the definition should explain loop behavior, what happens when the file is missing, and how to stop playback. None of that is present.

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 name format or the semantics of the loop flag. The schema only provides basic types and defaults, so the description adds no parameter-level meaning.

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

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

The description names a specific verb and resource: play an existing .rso sound file stored on the NXT. This clearly distinguishes it from siblings like play_tone and stop_sound.

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 'existing .rso sound file stored on the NXT' implies the file must already be present and hints at the alternative of using play_tone for tones, but there is no explicit when-to-use or when-not-to-use guidance.

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

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

Annotations already indicate that the tool is not read-only, not idempotent, and not destructive, but the description adds no behavioral context beyond that. It does not disclose whether the call blocks until the tone finishes, interrupts other sounds, or returns a value.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. It is appropriately concise for a simple 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?

While the tool is simple and the schema covers optional parameters with defaults, the description is too sparse to be contextually complete. It lacks usage guidance, return/blocking behavior, and how this relates to sibling sound tools, leaving important operational context to the agent's guesswork.

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

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

Schema description coverage is 0%, and the description does not mention frequency_hz or duration_ms at all. It also does not explain valid ranges, units beyond what the parameter names already imply, or the meaning of the defaults, so it fails to compensate for the missing 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 'Play a tone on the NXT brick' uses a specific verb and resource, clearly stating the action. It also distinguishes itself from the sibling 'play_sound_file' by indicating a tone rather than a sound file.

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

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

The description gives no guidance on when to use this tool versus alternatives such as play_sound_file or stop_sound. It states only what the tool does, leaving the agent to infer when it should be selected.

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

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

Annotations already supply the read-only and non-destructive profile, and the description's 'Query' wording is consistent with those hints. It adds the scope detail (brick plus all motor and sensor port states) but doesn't disclose output characteristics such as volume or response shape; with annotations present, this is adequate.

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

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

The entire description is one lean, front-loaded sentence with no filler. Every word contributes to stating the operation's object and scope.

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

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

For a no-required-parameter, read-only query with an output schema, the description covers the core operation. It is slightly incomplete in usage routing and parameter explanation, but the low complexity keeps the gap minor.

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% and the description never mentions the `format` parameter. The enum/default in the schema makes the parameter self-explanatory, but the description fails to add any meaning about how text vs json output differs.

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 ('Query') and names the full resource scope ('the brick and all motor and sensor port states'). It clearly conveys an aggregate state-snapshot operation, though it doesn't explicitly distinguish itself from siblings like nxt_info.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The 'all' scope implies this is for a complete state snapshot rather than a per-port query, but no alternative tools are named.

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

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

The readOnlyHint annotation already conveys that this is a safe, non-destructive read, and the description adds useful context about the file location and bounded/UTF-8 constraints. However, it does not disclose what happens when max_bytes is exceeded, whether the file must exist, or how errors are reported. The description adds some behavioral context but leaves important edge-case behavior undocumented.

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 sentence with no filler, and it front-loads the key action and object. Every word contributes meaning, and the qualifiers are relevant to correct invocation. This is a model of concise, efficient tool 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 two-parameter read operation, the description is mostly adequate, but it omits return-value behavior and edge cases such as oversized files, missing files, or path conventions. With no output schema and 0% parameter-schema coverage, the description should have provided a bit more operational detail to be fully complete.

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

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

Schema description coverage is 0%, so the description must carry the burden of explaining parameters. 'Bounded' loosely hints at max_bytes, but the description never explicitly explains that name identifies the file path or how max_bytes caps the read. An agent can guess from the parameter names, but the description adds little beyond the schema's own labels.

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 specifies the action (read), the resource (a file), and the location (NXT user flash), making it easy to distinguish from sibling tools like delete_file, list_files, and write_file. The qualifiers 'bounded' and 'UTF-8-compatible' add precise scope. This is a strong, unambiguous purpose statement.

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 about when to use this tool versus alternatives, such as list_files for enumerating files or write_file for creating files. The description implies reading, but it never states exclusions or directs the agent to a sibling when appropriate. An agent must infer usage entirely from sibling names.

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 says 'configure,' which implies a side effect on the sensor port, while annotations declare readOnlyHint=true. It also fails to disclose whether the read is blocking, what value is returned, or how sensor_type affects the read. This contradicts the read-only annotation.

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

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

The description is one short sentence with no filler, and the core action is front-loaded. It is appropriately concise, though it sacrifices informative content 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?

With no output schema, no parameter documentation, and several closely related sibling tools, the description does not tell an agent what the read returns or how it differs from raw and relative reads. This is incomplete for reliable selection and 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 meaning of port or sensor_type beyond the schema's enum names. The phrase 'one sensor port' weakly maps to the parameters but adds no real semantic detail, so the description fails to compensate for the missing schema documentation.

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

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

The description states a specific action ('configure and read') and resource ('one sensor port'), so an agent can grasp the general purpose. However, it does not differentiate this from sibling tools like read_sensor_raw or read_sensor_relative, and 'configure' is slightly ambiguous about whether configuration is persisted.

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

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

There is no guidance about when to use this tool instead of read_sensor_raw, read_sensor_relative, wait_sensor, or sensor_stream. The selection decision is left entirely to inference from tool names, which is insufficient for reliable tool 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds that multiple value categories are returned, but does not explain output structure, units, or the effect of optional parameters.

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. It is appropriately concise, but the extreme brevity leaves out guidance that would make it more useful.

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

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

With no output schema, zero parameter documentation, and several similar sibling tools, the description is too thin. It does not clarify what sensor_type null means, how return values differ from read_sensor, or when this tool is the right choice.

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

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

Schema description coverage is 0% and the description does not mention port or sensor_type at all. The agent is left with only the enum constraints and must infer what sensor_type affects about the returned values.

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

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

The description clearly states the tool returns sensor values in raw, normalized, scaled, and firmware forms, which is a specific verb-resource pairing. It distinguishes itself from sibling tools like read_sensor_relative, though it does not explicitly name the alternative.

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

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

Usage context is only implied: if an agent needs all four sensor value representations, this is the tool. However, there is no explicit guidance about when to choose this over read_sensor, read_sensor_relative, or sensor_stream.

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

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

Annotations already declare the operation read-only and non-destructive. The description adds the important behavioral dependency that readings are deltas from a prior zero reference. It does not describe the error case if no reference has been captured, but core behavior is sufficiently transparent for this simple read.

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

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

A single, front-loaded sentence that states the operation and the key precondition without filler. Every word contributes to the tool's 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?

For a two-parameter, read-only tool with no output schema, the description gives the essential purpose and dependency. It omits an explicit pointer to zero_sensor_reference and the return format, but neither is critical given the operation's simplicity.

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

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

Schema description coverage is 0%, and the description does not explain the port or sensor_type parameters; it only references 'sensor zero reference' in a general way. The enum values are self-explanatory, but the description does not compensate for the missing 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 uses a specific verb ('Read') and a specific resource ('change from a previously captured sensor zero reference'). It clearly differentiates from sibling read_sensor and read_sensor_raw by centering on a relative measurement rather than an absolute or raw reading.

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 'previously captured sensor zero reference' implies the tool should be used after zero_sensor_reference has been run, but it does not explicitly state when to prefer this tool over read_sensor or read_sensor_raw, nor does it mention exclusions.

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

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

Annotations declare the tool is not read-only, not idempotent, and not destructive, but the description adds almost no operational detail. It does not say whether execution blocks until completion, how timeout_seconds affects the run, what happens on failure, or whether a behavior must first be submitted.

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 redundant filler, and the main action is front-loaded. It is appropriately compact, though brevity contributes to its lack of completeness.

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

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

With no output schema and annotations that carry almost no behavioral information, the description shoulders the full burden and falls short. Missing details include return behavior, error conditions, relationship to submit_behavior/validate_behavior, and the meaning of 'monitored robot interface'.

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 never mentions name or timeout_seconds. The term 'saved behavior' helps infer that name identifies a saved behavior, but timeout_seconds is left entirely unexplained.

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

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

The description names a specific action ('Run') and resource ('a saved behavior'), so the tool's core purpose is identifiable. However, it doesn't distinguish run_behavior from sibling start_program, which could also be interpreted as executing something saved.

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 statement about when to use this tool instead of start_program, get_behavior, or validate_behavior. The phrase 'saved behavior' implies a prerequisite exists, but no conditions or exclusions are 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?

The description discloses the essential behavioral trait that the motor keeps moving until explicitly stopped, which goes beyond the annotations' simple readOnly/idempotent flags. It does not mention power semantics, the need for a later stop_motor call, or whether the call blocks, but the core persistent side effect is clearly communicated.

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. Every word adds value, and the most important behavioral detail—continuous motion until stopped—is front and center.

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 omits crucial context around parameter semantics and how to terminate the motion. With no output schema and no parameter descriptions, an agent is left guessing about power ranges, regulated behavior, and the connection to stop_motor.

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 information about power, port, or regulated. An agent cannot infer valid power range, sign conventions, units, or the meaning of the regulated flag from either the schema or 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 uses a specific verb and resource ('run a motor') and adds a key behavioral qualifier: 'continuously; it keeps moving until explicitly stopped.' This distinguishes it from one-shot movement tools like move_motor_relative and from conditional tools like run_motor_until_sensor, though it does not name those siblings explicitly.

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

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

The description implies use when continuous motor motion is desired, but it does not state when to prefer alternatives such as run_motor_until_sensor, run_motors, or stop_motor. There is no explicit when-not guidance or alternative routing.

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

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

Annotations are all false and provide little safety or read-only context, so the description carries the behavioral burden. It adds that motors run together with continuous signed power, which implies ongoing movement and direction, but it does not disclose that motors keep running until stopped, whether the call blocks, or how the `regulated` flag affects behavior. This is partial transparency.

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

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

Single sentence with the action verb front-loaded and no filler. Every word contributes to identifying the tool's behavior.

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 3 parameters, no output schema, and many motor-related siblings, the description is enough to identify intent but not fully enough to invoke correctly. Missing details include array correspondence, stop behavior, and `regulated` semantics; these gaps matter more because the schema itself has no field descriptions.

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 to `ports` and `powers` by stating 'one to three motors' and 'signed continuous power', which the bare schema does not convey. However, with 0% schema description coverage, it should clarify more: it does not explain that `ports` and `powers` correspond element-wise, power ranges, port uniqueness, or what the optional `regulated` parameter controls.

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

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

Verb 'Start' plus resource 'motors' and explicit scope ('one to three', 'together', 'signed continuous power') clearly identifies a multi-motor continuous-power command. This distinguishes it from siblings like run_motor (single motor), move_motors_* (position moves), and stop_motors (stopping).

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 multi-motor continuous-power use case, but it does not explicitly state when to prefer this tool over run_motor, move_motors_relative, or run_motors_until_sensor. There are no exclusions or alternative routing hints, so the agent must infer usage from sibling names and context.

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

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

Annotations only show readOnlyHint=false and non-destructive, so the description adds the key behavioral trait that operation stops on sensor condition or safety limit. It does not detail blocking behavior or side effects, but the core stop behavior is disclosed beyond what annotations provide.

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 repetition. Every word contributes to meaning, and it clearly identifies the operation and termination criteria.

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 10 parameters, no output schema, and non-trivial configuration (sensor type, threshold, condition, multiple motor ports/powers, safety limits), this description is too thin. It fails to convey how parameters relate to each other or what a successful invocation requires.

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 mentions only broad concepts like 'sensor condition' and 'safety limit.' It does not explain how ports, powers, brake, regulated, threshold, condition, or timeout interact, leaving the agent to infer all parameter semantics from schema enums and defaults.

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 ('Run a motor group') and a clear termination condition ('until a sensor condition or safety limit'). It distinguishes this from simple run_motors by emphasizing the stop condition, and from run_motor_until_sensor by using 'motor group' (plural).

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 'until a sensor condition or safety limit' clearly implies when this tool should be used: when motors must run until a sensor triggers or a safety limit is reached. It does not explicitly name alternatives or exclusion conditions, but the usage context is clear and not misleading.

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 all annotations false, the description carries the full burden. It doesn't disclose that the motor will physically move, whether the call blocks until a condition is met, what happens after stopping (brake behavior), or any side effects. 'Run a motor' implies motion but no further details.

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

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

The description is a single, efficient sentence with no redundancy, but it is under-specified for the tool's complexity. It front-loads the purpose but omits essential behavioral and parameter detail, so brevity does not equate to effective structure.

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

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

Given 10 parameters, no annotations, no output schema, and no parameter descriptions, the description is incomplete. An agent cannot infer how to set sensor_type, threshold, regulated, or brake, nor understand the blocking nature or return behavior. The three listed stop conditions are the only concrete 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 coverage is 0%, so the description must compensate for parameter meaning. It hints at three stopping triggers (sensor condition, timeout_seconds, max_ticks) but leaves power, brake, regulated, sensor_type, threshold, and condition values unexplained. The mapping is partial and insufficient for correct invocation.

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

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

The description states a specific verb ('Run') and resource ('a motor') with a clear stopping condition ('until a sensor condition, timeout, or travel limit'). It distinguishes from simpler tools like run_motor and plural variants like run_motors_until_sensor, though it doesn't explicitly name 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 explicit guidance on when to use this tool versus siblings such as run_motor, run_motors_until_sensor, or cycle_motor_on_touch. Usage is only implied by the name and the three stopping conditions, leaving selection to inference.

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

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

Annotations are all false, so the description carries the full burden of behavioral disclosure, yet it only says the series is bounded. It does not state whether the call blocks, how termination is determined, whether it starts a background stream, or what side effects (if any) 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 compact sentence with no filler and the main action is front-loaded. It is efficiently written, though it is so minimal that it sacrifices useful explanatory content.

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

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

With 5 parameters, no output schema, and no annotation support, the description omits essential context such as termination conditions, sample rate/count semantics, return structure, and how this tool differs from sibling sensor tools. An agent cannot reliably predict the behavior or result of a call.

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 no parameter-level meaning. It does not explain how max_samples, duration_seconds, and sample_interval_ms interact, nor does it clarify valid port/sensor_type combinations beyond the raw enums.

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 ('Collect') and resource ('sensor readings') with the qualifier 'bounded series,' which conveys the core function of gathering multiple samples. It is distinguishable from single-reading siblings like read_sensor, but it does not explicitly name or contrast them.

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

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

There is no guidance about when to use sensor_stream versus read_sensor, read_sensor_raw, wait_sensor, or log_start. The phrase 'bounded series' implies multi-sample collection, but no explicit when/when-not conditions or alternative routing is provided.

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

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

The description discloses that this is a mutating operation that writes the NXT's display name, and the 'short ASCII' note hints at value constraints. It does not mention persistence, overwrite behavior, or failure modes, though annotations already indicate it is not read-only or destructive.

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 concise sentence states the action and target with no filler. The essential constraint ('short ASCII') is included in the same front-loaded sentence.

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 setter with no output schema, the description covers what the tool does and what the parameter represents. It may omit minor details like exact length limits, but the tool's simplicity and the 'short ASCII' qualifier make it adequately complete.

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

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

With 0% schema description coverage, the description provides the only meaning for the 'name' parameter: it is the short ASCII display name for the NXT. It does not specify maximum length or exact allowed characters, but this is sufficient for a simple string parameter.

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

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

Description uses a specific verb ('Set') with a specific resource ('the NXT's short ASCII display name'), clearly indicating the action and target. It is unambiguous and distinct from siblings like nxt_info or list_files.

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

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

The intended use is implied by the name and description: call when the user wants to change the NXT display name. There is no explicit when-not-to-use or alternative routing, but no sibling tool offers the same operation.

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

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

Annotations provide no useful behavioral hints (all false), so the description carries the full burden. It only says 'Start' and does not disclose whether the call blocks, returns immediately, interrupts the current program, or what happens if the named program is not found.

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 front-loads the action and resource without repeating the tool name or schema details.

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

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

For a simple one-parameter tool, the description is minimally adequate: it states what is started and that it must already exist on the NXT. But with no annotations, no output schema, and no mention of execution behavior or alternatives, it leaves important context for an agent to infer.

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 only declares a string parameter named 'name'. The description's mention of a stored '.rxe program' weakly implies that 'name' should be the stored program name, but it does not clarify file extension formatting, name matching rules, or how to discover valid names.

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 ('Start') and resource (an '.rxe program already stored on the NXT'), making the tool's purpose clear. It doesn't explicitly contrast with siblings like run_behavior, but the '.rxe' qualifier provides enough distinction from behavior-focused 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 phrase 'already stored on the NXT' implies a prerequisite and a clear use case: launching an existing program file. However, it does not explicitly mention alternatives, such as run_behavior for behaviors or stop_program for stopping, so some inference is required.

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

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

Annotations already mark the operation as mutating, idempotent, and non-destructive. The description adds meaningful context by explaining that enabling brake means the motor actively holds its position, which is behavioral information not present in the schema or annotations. It does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every phrase earns its place: it names the action, the target, and the optional braking behavior.

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

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

For a simple two-parameter tool with clear annotations and an enum-driven schema, the description covers the core action and the key optional behavior. It could be more explicit about what happens when brake is false, but the schema default and the phrase 'optionally actively holding' make the intended behavior reasonably clear.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It only clarifies 'brake' through the phrase 'actively holding its position'; the 'port' parameter is not mentioned at all and relies entirely on the schema enum.

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 the specific verb 'Stop' and a singular resource, 'one motor', which clearly distinguishes it from sibling stop_motors. The phrase 'optionally actively holding its position' also explains the brake behavior in plain terms.

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

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

The description gives no explicit guidance on when to use this tool instead of stop_motors, emergency_stop, or other motor-related siblings. The only usage hint is implied by the singular 'one motor' and the optional brake flag.

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

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

Annotations already convey that the operation mutates state, is idempotent, and is not destructive, which lowers the burden on the description. The description adds the 'together' behavior, but it does not disclose what happens while stopping, whether the call blocks, or how the brake parameter affects motor behavior beyond the schema default.

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

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

The description is extremely concise: a single eight-word sentence with no filler. The action, object, and scope are 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 simple two-parameter tool with clear annotations, the description is minimally viable, but it omits important selection context versus emergency_stop and stop_motor. An agent could still invoke it correctly using the schema, but would benefit from knowing when the brake flag should be set or whether this is the right batch-stop tool for a scenario.

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 needed to clarify parameters, but it does not mention ports or brake by name. It only implies the ports array length through 'one to three', leaving brake semantics entirely to the schema.

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

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

The description uses a clear verb ('Stop') with a precise resource ('motors') and a scope ('one to three ... together'). It distinguishes this batch tool from the singular sibling stop_motor by emphasizing togetherness and plural motors.

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 'one to three motors together' implies the intended use case: stopping multiple motors in one call. However, it does not explicitly say when to use this tool instead of related siblings like emergency_stop, wait_motors, or stop_motor, or when the brake option should be used.

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

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

Annotations are all false, providing no safety or idempotency hints. The description only states the operation without elaborating on side effects, edge cases (e.g., behavior when no program is running), or whether the action is idempotent. This is a minimal disclosure for a mutation tool.

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

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

The description is one concise sentence with no filler. It is front-loaded with the essential action and target, making it immediately understandable without unnecessary elaboration.

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 tool with no output schema, the description is largely complete. It states the core function clearly. A minor gap is the lack of differentiation from emergency_stop, but this falls under usage guidance rather than completeness of the tool's own behavior.

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

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

The tool has zero parameters, and schema coverage is 100% (vacuously). Since there are no parameters to document, the baseline of 4 applies, and the description does not need to add parameter-level details.

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

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

The description clearly states the action ('Stop') and the specific resource ('the currently running .rxe program'). It is unambiguous and easily distinguishable from sibling tools like stop_motor or emergency_stop by naming the program type.

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

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

The description provides no guidance on when to use this tool versus alternatives such as emergency_stop or stop_motor. There is no mention of exclusions or scenario-based recommendations, leaving the agent to infer the appropriate context.

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

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

Annotations are all false, providing little behavioral safety context. The description adds the qualifier 'active', implying it only acts on ongoing playback, but it does not disclose behavior when no sound is active, nor idempotency beyond the annotations. Some value added, but no depth.

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

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

Single sentence with no extraneous words; the key action and target are front-loaded. Perfectly 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?

For a parameterless tool with no output schema, the description covers the essential behavior. It doesn't mention error cases, but the low complexity makes this acceptable.

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?

Tool has zero parameters and schema coverage is 100%, so there is nothing for the description to add. Baseline 4 for no-parameter tools.

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

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

States a specific verb ('Stop') and resource ('active brick sound playback'), clearly distinguishing it from play_sound_file/play_tone and from stop_motor/stop_program siblings. No ambiguity about the operation's target.

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?

Gives no guidance on when to use it vs alternatives such as emergency_stop or stop_program. The agent must infer context from the name and sibling list.

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

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

Annotations already signal a mutating but non-destructive operation (readOnlyHint=false, destructiveHint=false), and the description aligns by saying 'save.' It adds useful context about validation and the PC-side origin, but it does not disclose overwrite behavior, persistence semantics, or failure handling on invalid input.

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. It conveys the core action and object efficiently, earning each word.

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 two required parameters and no output schema, the description is too thin. It omits the expected workflow with sibling tools, what happens on validation failure, whether existing behaviors are overwritten, and what success looks like.

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 the lack of parameter documentation. It does not explain what 'name' or 'source' mean, although 'PC-side behavior' vaguely hints at the nature of 'source.' This is inadequate for an agent to confidently construct the two required 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?

Description states a specific action, 'Validate and save,' and a specific resource, 'trusted PC-side behavior.' This clearly distinguishes the tool from siblings like validate_behavior, run_behavior, get_behavior, and list_behaviors by emphasizing persistence on the brick.

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 given about when to use this tool versus alternatives. It does not mention that validate_behavior might be used first, nor when run_behavior or get_behavior/list_behaviors would be more appropriate. The word 'trusted' hints at the intended input class but leaves the workflow to inference.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds useful context beyond those annotations by explicitly stating that the behavior is neither saved nor run, and it scopes validation to restricted PC-side behaviors.

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. 'Without saving or running it' is a high-value qualifier that adds behavioral precision rather than filler.

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

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

For a one-parameter tool with rich annotations, the core purpose and side-effect profile are covered. However, the term 'restricted' is vague, there is no guidance on what validation produces, and the usage relationship to run_behavior and submit_behavior is only implied.

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 never mentions the source parameter or its expected format. The name and schema make it inferable that source is behavior source code, but the description does not compensate for the missing parameter documentation.

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

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

The description states a specific verb, 'validate', and a specific resource, 'restricted PC-side behavior'. The qualifier 'without saving or running it' clearly differentiates this from run_behavior and submit_behavior.

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 saving or running it' implies this is a dry-run validation tool and signals it is not for execution or persistence. However, it does not explicitly state when to prefer this over run_behavior or submit_behavior, leaving the usage context to inference.

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

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

The description discloses the core wait-then-timeout-stop behavior, which goes beyond the annotations. However, it leaves unclear whether stopping always occurs, what 'safely' means, whether braking is applied, and what happens during the wait.

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

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

The description is a single compact sentence with no filler. It front-loads the main action, but some of its brevity comes at the cost of important behavioral and parameter elaboration.

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 non-read-only tool with three parameters, no output schema, and no annotation support, this description is too thin. It lacks usage guidance, alternative routing, parameter clarification, and enough behavioral detail for an agent to call 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, but it barely does. 'Deadline' hints at timeout_seconds and 'motor ports' hints at ports, but brake is entirely unaddressed and no parameter is explicitly 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 states a specific action ('wait for motor ports to stop') and a secondary action ('stop them safely when the deadline expires'). This clearly identifies the tool's purpose and distinguishes it from ordinary stop_motors, though it could more explicitly contrast with wait_sensor.

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

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

The description gives no guidance on when to use this tool versus alternatives like stop_motors, emergency_stop, or wait_sensor. No context, exclusions, or conditions are provided.

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

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

With all annotations set to false, the description carries the full burden of behavioral disclosure. It openly states that the tool waits (implying blocking) and debounces the condition, and explicitly guarantees no motor movement—a safety-relevant trait. It does not mention timeout or return/error behavior, so it is not fully transparent, but it adds meaningful behavioral context.

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

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

The description is a single sentence of eleven words, with the core action front-loaded and no filler. 'without moving a motor' is a valuable qualifier that earns its place by preventing confusion with motor-acting siblings.

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 blocking operation with six parameters, no output schema, and unhelpful all-false annotations, the description is too sparse. It omits what happens on timeout (error vs. false return), whether the wait can be interrupted, and which conditions require threshold. The single sentence is an excellent purpose statement but not complete operational 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%, so the description must compensate for undocumented parameters. It adds only the notion of 'debounced', which relates to debounce_ms, but it does not explain threshold, the condition operators (lt, lte, gt, gte, eq), timeout_seconds, or sensor_type semantics. The schema enums and defaults carry nearly all parameter meaning.

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 ('Wait') with a specific resource ('debounced sensor condition'), and adds the critical qualifier 'without moving a motor', which clearly distinguishes it from motor-driving siblings like run_motor_until_sensor or run_motors_until_sensor. It is a crisp, non-tautological statement that an agent can act on.

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 moving a motor' provides clear usage context: use this when you need to block on a sensor condition and do not want motor motion. However, it does not explicitly name alternatives such as read_sensor for immediate single reads or run_motor_until_sensor for motor-inclusive waits, so the guidance is clear but not exhaustive.

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

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

Annotations already show this is a mutation (readOnlyHint=false) and not idempotent. The description adds useful context about bounded writes and sound-file support, but it does not explain overwrite behavior, failure conditions, or whether content requires special encoding.

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

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

The description is a single compact sentence with the action front-loaded and no filler words. It is appropriately concise, though it sacrifices detail 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 write operation with three parameters and no output schema, this description is too thin. It omits parameter semantics, overwrite behavior, file-size bounds, and encoding expectations, so an agent would likely need to guess or rely on external knowledge to call this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it only says 'data or sound files' without connecting this to the name, content, or overwrite parameters. The schema provides bare titles and a default, so an agent still lacks crucial parameter meaning such as how content should be formatted or what name represents.

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

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

The description names a specific verb ('Write') and resource ('bounded data or sound files to NXT user flash'), clearly distinguishing this from siblings like read_file, delete_file, and list_files. The 'bounded' qualifier adds useful specificity about file size constraints.

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 a file needs to be created or persisted on NXT user flash. However, it provides no explicit when-not-to-use guidance and does not name alternatives, leaving usage decisions mostly to inference.

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

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

The description discloses the two primary behavioral effects: halting the motor and resetting the encoder reference. This adds meaningful context beyond the annotations (readOnlyHint=false, idempotentHint=true) and does not contradict them.

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

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

The description is a single, compact sentence with no filler or redundant information. Every word contributes to understanding 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?

For a single-parameter, no-output-schema tool with annotations indicating idempotency and non-destructiveness, the description is adequately complete. The main gaps are the lack of usage differentiation and any statement about return behavior, but these are minor given the tool's simplicity.

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

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

With schema description coverage at 0%, the description must compensate for parameter documentation, but it never mentions the 'port' parameter. The schema's enum is the only source of meaning for the parameter, and the description adds nothing to 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 specific verbs and resources: 'Stop a motor' and 'reset its absolute encoder reference to zero.' This clearly conveys the operation and distinguishes it from siblings like stop_motor and zero_sensor_reference.

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 stop_motor or zero_sensor_reference. There are no stated conditions, exclusions, or mention of prerequisites, leaving the agent to infer usage purely from the operation name.

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

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

Annotations are all false and provide no safety or state-change context, so the description must carry the behavioral burden. It implies a state change—setting a zero reference—but does not disclose whether this overwrites an existing reference, persists across programs, affects only the selected sensor, or triggers any feedback. No contradiction exists, but the behavioral picture is minimal.

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. The key action ('Capture... as relative zero') is front-loaded, and the sentence is appropriately sized for a tool with only two enum-constrained parameters.

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

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

The description is sufficient to guess the basic action and parameters, but it does not explain the effect on later relative reads or what the caller should expect in return. Since there is no output schema and no annotations describing behavior, a brief note about the calibration effect would make this complete for an agent deciding whether to call it before read_sensor_relative.

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 clarifies that sensor_type refers to light, color-intensity, or ultrasonic measurements and that the value is the current reading, but it adds nothing about the port parameter beyond the schema's title and enum. Thus only one of two parameters gains meaningful context.

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 clear verb ('Capture') and resource ('current light, color-intensity, or ultrasonic value') and states the transformation ('as relative zero'). It is distinguishable from tools like zero_motor_position by the sensor-specific focus, though it does not explicitly differentiate itself from read_sensor_relative or read_sensor.

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 about when to use this tool versus alternatives such as read_sensor_relative, read_sensor_raw, or zero_motor_position. The likely prerequisite relationship to relative sensor readings is only implied by the phrase 'relative zero' and is not explicitly stated.

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