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

No annotations are provided, so the description carries the burden. It usefully discloses the returned fields and clarifies that position 0 means off, but it does not explicitly state that the tool is read-only, has no side effects, or requires any specific connection state. The 'status' framing implies a read, but explicit behavioral guarantees are absent.

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 dense sentence that lists the relevant status categories without filler. It is appropriately sized, though it opens with a noun list rather than a clear 'Returns...' verb, which slightly reduces front-loading.

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 status tool with no output schema and no annotations, the description gives a comprehensive inventory of returned data, including the important '0 = off' meaning. It lacks an explicit read-only/no-side-effects statement, but otherwise contains what an agent needs to invoke it correctly.

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

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

The tool takes zero parameters, so there is no parameter semantics to document. The baseline for a parameterless tool is 4, and the description does not introduce confusing parameter-like 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?

Lists exactly what board status data is returned: rail current/voltage, faults, protection limits, and per-channel name, mode, travel limits, speed, and current position. The verb is implicit rather than stated, but the resource and scope are specific enough to distinguish it from focused tools like read_analog or measure_current.

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

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

Provides no guidance on when to call this versus siblings such as measure_current, read_analog, list_poses, or script_status. The agent must infer that this is a broad board overview rather than a targeted measurement or pose listing.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the fault types and the outcome, but does not mention safety preconditions, side effects, permissions, or what happens if no fault is latched.

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 states the action and its purpose immediately.

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 hardware command with an output schema, the description gives enough to invoke it correctly. It could be more complete by stating preconditions or safety implications, but the core behavior is covered.

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

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

The tool takes zero parameters, so there are no parameter semantics to clarify. The baseline score of 4 is appropriate because the empty schema is fully self-explanatory.

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: 'Clear a latched overcurrent/undervoltage fault.' It also states the resulting effect, 'so channels can move again,' which distinguishes it from sibling tools like set_protection or stop_all.

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 by the condition 'latched overcurrent/undervoltage fault' and the goal of restoring channel movement. However, the description does not explicitly say when not to use it or name alternatives such as board_status or set_protection.

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

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

With no annotations, the description carries the full behavioral burden and usefully discloses that the servos go limp, which is meaningful beyond the schema. However, it does not mention safety implications, whether torque can be restored, or whether disabling while moving is safe.

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 the action front-loaded and no wasted words. The parenthetical clarifying channel identifiers is compact and useful.

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

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

For a simple one-parameter tool with an output schema, the description is adequate but thin. It omits safety context, invalid-channel behavior, and its relationship to stop_all, which matters for correct selection.

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

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

Schema description coverage is 0%, so the description must compensate. It adds that channels may be numbers or names, which is useful, but it does not specify valid ranges, naming format, or examples.

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

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

The description states a specific verb and resource: stopping the driving of given channels, with a clear physical effect that the servos go limp. It is easy to distinguish from move_servos, but it does not explicitly distinguish itself from stop_all or clarify its place among siblings.

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

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

The description implies the action but gives no explicit when-to-use guidance, prerequisites, or alternatives. In particular, it does not explain when to use disable_servos rather than stop_all or move_servos.

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

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

With no annotations, the description carries the full burden. It usefully discloses blocking behavior via 'wait until it arrives', which is important for a motion tool. But it omits failure modes, timeout behavior, whether motion is interruptible, and safety implications.

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

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

A single compact sentence with zero waste. The key blocking behavior is front-loaded alongside the primary action.

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 motion tool with no annotations, no output schema, and undocumented parameters, the description is too thin. It covers the core action and blocking wait but leaves duration semantics, failure behavior, and return expectations unspecified.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It indirectly implies that 'name' refers to a saved pose from list_poses, but it says nothing about duration_s, its default, or its effect on motion timing.

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 and resource ('Move to a saved pose') and distinguishes it from list_poses by pointing there for pose names. It is more specific than a tautology, but lacks detail on what a 'pose' entails in this robot context.

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

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

It implies the prerequisite of having a saved pose by saying 'see list_poses', which is useful routing. However, it gives no explicit when-to-use or when-not-to-use guidance relative to siblings such as move_servos or play_sequence.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about read-only safety, the return shape, or whether the sequence is included or just its name. Only the origin of the data (servogui.json) is disclosed.

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?

It is a single short fragment with no padding, but it is not a complete sentence and is under-specified rather than concise. Nothing is front-loaded because there is no verb clause to lead with.

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, zero-parameter read tool this could be complete in one sentence, but with no output schema the description should at least say what a caller gets back (pose names, coordinates, stored sequence). That essential information is absent.

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

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

The tool takes zero parameters, so the schema has nothing to document and there is no parameter semantics to compensate for. Baseline 4 applies.

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

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

The name supplies the verb ('list') while the description only names the resource: 'Poses and the sequence saved from the GUI (servogui.json).' The reference to the GUI-saved file is a useful distinguishing detail beyond a pure restatement of the name, but the fragment never states that it lists or returns anything.

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 indication of when to call this versus go_to_pose or play_sequence, which operate on the same pose/sequence data. The agent is left to infer that this is the retrieval counterpart to those action tools.

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

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

With no annotations, the description carries the full burden; it does disclose the sampling mode ('continuously') and the return statistics, which is genuine behavioral value. However, it omits whether the call blocks for the sampling window, sampling rate, error/overflow behavior, or permission requirements.

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

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

One front-loaded sentence with no filler, but it is arguably too terse for a tool whose only parameter and blocking behavior need explaining.

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?

Reasonable for a single-parameter tool with no output schema, since the description covers the return statistics. Still missing the meaning/units of 'seconds' and how long the call actually takes, which an agent needs to invoke it correctly.

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

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

Schema description coverage is 0% for the single 'seconds' parameter (default 1), and the description never mentions a duration argument at all — 'continuously' only weakly implies a sampling window. The description fails to compensate for the undocumented 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?

States a specific verb and resource ('Sample the servo-rail current') and describes the return payload (peak, mean, min mA). It is distinguishable from generic siblings like read_analog, though it never names 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?

No indication of when to use this versus read_analog, nor any prerequisite such as servos needing to be enabled or the port being open. Usage is only implied by the tool name and 'continuously'.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the call waits until arrival, that positions are clamped to channel limits, and that channels are turned on if off. It does not mention error handling or permission requirements, but the core behavioral traits are covered.

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

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

Three short sentences, front-loaded with the primary action and followed by essential parameter details. Every sentence earns its place with no filler.

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

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

The description explains the nested positions object, the blocking wait, clamping, and power-on side effect. For a tool with no output schema and no annotations, this is nearly complete. Minor gaps include error behavior for unknown channels and confirmation of the default duration.

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

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

Schema coverage is 0%, but the description compensates by explaining the nested positions object format, giving an example, and clarifying duration_s semantics (0 means each channel's own speed). It does not mention the default duration of 1, but otherwise adds substantial meaning beyond the schema.

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

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

The description states a specific verb and resource: 'Move one or more servos and wait until they arrive.' It is clear what the tool does, though it does not explicitly distinguish itself from siblings like go_to_pose or play_sequence.

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 by describing the blocking wait and the effect of turning channels on. However, there is no explicit guidance on when to use this tool versus go_to_pose, play_sequence, or stop_all, nor any stated preconditions.

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

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

With no annotations, the description carries the full burden and does add real behavioral facts: it repeats the saved move/hold times, aborts early on a fault, and is capped at 120 s. It omits whether the call blocks for up to that 120 s and whether stop_all can interrupt it.

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

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

Two compact sentences, with the core action front-loaded and the constraints second. No filler or restatement of the name.

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

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

For a one-parameter, no-annotation, no-output-schema tool, the description supplies the essentials an agent needs: loop count semantics, fault behavior, and a hard time cap. Missing only call-blocking/return behavior and failure modes such as no sequence being saved.

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

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

Schema coverage is 0% and the single `loops` parameter has only a default of 1, so the description does the work by explaining it means the sequence is repeated that many times. That fully covers the one parameter; a 5 would need edge cases like loops=0 or a maximum.

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?

Specific verb ('play') plus resource ('the GUI's saved sequence of poses'), which clearly distinguishes it from single-pose tools like go_to_pose and script tools like run_script. It does not explicitly name a sibling as an alternative, so it stops short of a 5.

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

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

Usage is only implied by the resource: play a previously saved sequence. It gives no explicit guidance on when to prefer this over run_script, go_to_pose, or list_poses, and no prerequisites such as needing a sequence already saved or the port being open.

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

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

With no annotations, the description carries the full burden; it does disclose the meaningful behavioral trait that readings are 0-4095 counts mapping to 0-3.3 V, which tells the agent how to interpret results. It does not state that the operation is side-effect free or describe the response shape, leaving gaps for an annotation-free 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?

One sentence, front-loaded with the verb and resource, with the range and voltage mapping as compact parenthetical detail. Nothing is redundant or wasted.

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 tool with no output schema, the description covers the input range and the units of the returned value, which is the most important missing piece. It still omits the response structure and error behavior for invalid channels, so it is adequate rather than complete.

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

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

Schema coverage is 0% and the single parameter is an undescribed string type, so the description must compensate. It partially does by giving the valid range "0-7", but it never clarifies the expected string encoding versus an integer or what happens with out-of-range 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 pairs a specific verb ("Read") with a specific resource ("channel 0-7 as an analog input") and even states the value encoding, so the agent knows exactly what operation occurs. It is clearly distinguishable from siblings like measure_current or board_status, though it doesn't explicitly name 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 on when to choose this tool over alternatives such as measure_current or board_status, nor any preconditions or exclusions. The only implicit usage cue is the channel range 0-7.

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

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

With no annotations, the description carries the full burden and delivers: the side effect on servo state ('servos keep holding'), the lifecycle behavior ('reopens automatically on the next tool call'), and the reason the operation exists. It omits failure semantics — what happens if the port is already released or if a command is in flight.

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

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

Two short sentences, imperative and front-loaded with the action, followed by the state consequence and the auto-reopen behavior. Every clause carries information an agent needs.

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 lifecycle tool with an output schema available, the description covers action, side effect, and re-acquisition behavior. Only error/edge-case handling is absent, which is minor given the output schema can carry the result detail.

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

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

The tool takes zero parameters, so the schema-level baseline is 4. The description correctly implies no arguments are needed, and there is nothing further to disambiguate.

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

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

States a specific verb and resource (close the serial port) with immediate scope ('now') and a concrete consequence ('servos keep holding'). No sibling tool in the list does anything similar, and the description makes that exclusivity obvious by naming the external consumers (GUI, flash.py) that need the port.

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 a clear trigger condition — release when the GUI or flash.py needs the board — which effectively says when to use it. It does not state exclusions explicitly (e.g., don't bother calling if you are about to make another tool call), though the auto-reopen note implies that.

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

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

No annotations are provided, so the description carries the full behavioral burden. "From the top" adds one useful execution detail, but it does not disclose whether the call blocks, what happens if no script is stored, or how execution interacts with stop_script.

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. The key action and starting point are stated immediately.

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 output schema can cover return values, and the zero-parameter schema is simple. However, for an action tool with no annotations, the description omits prerequisites, error behavior, and how it relates to upload_script or stop_script, leaving meaningful operational context missing.

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

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

The tool has zero parameters and the schema is empty with 100% description coverage, so there are no parameter semantics to explain. Baseline 4 is appropriate for a parameterless tool.

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

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

The description uses a specific verb, "Start," and names the resource, "the stored script," plus scope, "from the top." It is clearly distinguishable from stop_script and script_status, though it does not explicitly name siblings or prerequisites.

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

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

It implies the tool executes a stored script, but gives no when-to-use guidance, no when-not-to-use guidance, and no prerequisites such as whether upload_script must run first. The relationship to stop_script and script_status is left for the agent to infer.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a harmless query (nothing about mutation, permissions, or side effects) and does name the return contents, but it says nothing about cost, latency, or failure modes when no script is uploaded.

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

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

A single compact sentence with zero filler, and the core information (stored script + running state) is front-loaded. Nothing would be gained by trimming it further.

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

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

With no output schema and no annotations, the description is the only source of return-value information, and it only sketches the shape (a script identity and a running flag) without stating the format or what happens when nothing is stored. Adequate for a zero-arg query but not fully self-sufficient.

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

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

The tool takes zero parameters, so the baseline is 4. There are no arguments whose semantics the description would need to clarify.

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 two facts the tool retrieves: which script is stored on the board and whether it is currently running. That is a specific resource (board script state), though it never names how it differs from the sibling board_status, which an agent may see as overlapping.

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 and no mention of alternatives such as board_status or run_script. The read-only intent is only implied by the interrogative phrasing.

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

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

With no annotations, the description carries the full burden and does substantive work: it discloses the 7500 mA hard cap, the ~5 A continuous budget as practical context, and that settings reset at power-up (non-persistent). It stops short of saying what happens on a trip or who consumes the resulting fault, but the safety-critical behavior is well conveyed.

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

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

Three tight sentences with zero filler; the disable rule and safety cap are front-loaded and the persistence note closes cleanly.

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?

A hardware-mutating, no-annotation, no-output-schema tool needs strong behavioral coverage. The description covers caps and persistence but omits trip behavior, undervoltage semantics, and any return/confirmation detail an agent might want.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies overcurrent_ma's cap (7500 mA) and that 0 disables both limits, but adds nothing about undervoltage_mv's range or behavior beyond the disable case, leaving one parameter largely undocumented by the name alone.

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

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

States a specific verb (Set) and resource (rail trip limits), making clear it configures protection thresholds rather than measuring or clearing faults like its siblings. It doesn't explicitly name a sibling alternative, but the 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 parenthetical '(0 disables either)' gives a useful operating hint on how to turn off a limit, but there is no guidance on when to call this versus siblings like clear_faults or measure_current, nor any prerequisite context.

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

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

With no annotations, the description must carry the behavioral load: it discloses that all channels are switched off and that the effect is immediate. It does not state the resulting state, whether motion halts abruptly or smoothly, or whether recovery is needed afterward.

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 with zero waste; the urgent intent is apparent from the first 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 parameterless tool with an output schema present, the description covers the essentials of what happens and how fast. Minor gaps remain around post-stop state and recovery, but nothing critical to correct invocation is missing.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly conveys that no arguments are involved in this blanket stop action.

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

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

States a specific verb and scope: stopping every channel immediately. The phrase 'every channel' distinguishes it from the sibling stop_script, though it never names that sibling explicitly.

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

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

'Panic stop' implies emergency use, giving context for when to reach for it. However, it never states when-not to use it or points at alternatives like stop_script or disable_servos, leaving routing 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?

With no annotations, the description carries the full behavioral burden and usefully discloses the key post-condition: servos keep their positions. It does not describe idempotency or error behavior, but the central side effect is made clear.

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 main action front-loaded. The parenthetical alternative is placed efficiently and every clause adds useful 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 zero-parameter action tool with an output schema, the description provides enough context to invoke it correctly. It covers the action, the relevant servo behavior, and the closest alternative.

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

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

The tool takes zero parameters, so there are no parameter semantics to explain. The baseline score for a no-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 states a specific verb and resource: "Stop the stored script." It also distinguishes this from the sibling stop_all by explaining that servos keep their positions here, while stop_all lets go.

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

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

It clearly implies when to use this tool: stop the script without releasing servos. It also names the alternative stop_all for releasing servos, though it does not explicitly cover failure or no-script conditions.

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

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

With no annotations, the description carries the burden well: it discloses compilation, flash persistence, autorun-across-power-ups, clamping to channel limits, and a hard 254-instruction cap. It omits whether an upload overwrites the existing stored script and whether a board connection/port is required, which matters for a write 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?

Front-loaded purpose sentence, then a scannable grammar block with per-instruction semantics and edge cases (non-blocking move, repeat-move waiting, loop count semantics). Dense but every line carries information an agent needs to author valid input.

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?

No output schema and no annotations, so the description must stand alone; it does so for the script DSL and limits, which is the hard part. The remaining gap is the unexplained 'run' flag and the absence of overwrite/idempotency behavior for the stored flash content.

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

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

Schema coverage is 0%, so the description must carry all parameter meaning. It does explain 'autorun' ('also start at every power-up') but leaves 'run' completely unaddressed and never connects script-text format to the script parameter beyond the grammar listing.

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

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

States a specific verb and resource ('compile a servo script and store it in the board's flash') plus the distinguishing consequence: the firmware executes it without a PC. That scope separates it from play_sequence/run_script at a glance.

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 by the flash/autorun framing (persistent, PC-independent execution) but no sibling is named, so the agent gets no explicit rule for choosing upload_script over run_script, play_sequence, or go_to_pose. The autorun parenthetical hints at a persistence decision but doesn't route the call.

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