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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states only that a single frame is captured; it does not mention whether the frame is saved, returned, or streamed, nor any permissions, delays, or side effects. This is a minimal behavioral statement with little transparency.

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

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

The description is a single concise sentence that front-loads the action, resource, and scope ('single frame'). Every word contributes meaning and there is no redundant or boilerplate content.

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

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

For a zero-parameter tool, the description is arguably sufficient to invoke: the agent can call it with no inputs. However, because there is no output schema and no annotation context, the missing return/behavior details leave some ambiguity about what the agent should expect after the call, so it is adequate but not fully complete.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly adds no parameter information because there is nothing to add; there are no input semantics 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 uses a specific verb ('Capture') with a clear resource ('a single frame from the robot's camera'). It is distinct from siblings like reachy_start_webrtc_stream, which implies continuous video, and reachy_check_camera, which implies testing rather than capturing a frame.

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 'single frame' implies use when a still image is needed, and implicitly contrasts with streaming or checking. However, no explicit guidance is provided about when to prefer this over reachy_check_camera or reachy_start_webrtc_stream, so the usage context is only implied.

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

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

No annotations are present, so the description must bear the full behavioral disclosure burden. It states that a test frame will be captured, but doesn't say whether the frame is stored, returned, discarded, whether this has side effects on the camera stream, or what the success/failure response looks like.

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 purpose and method without fltelling. Every word contributes meaning, 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?

The tool is simple and parameterless, so the description is largely sufficient for invocation. However, with no output schema and no annotations, the exact result format or criteria for 'working' remains unspecified, leaving a small but real gap.

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

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

The tool has zero parameters and the schema coverage is 100% trivially. Since there are no inputs to explain, the description has no parameter semantics burden beyond confirming the operation takes no arguments.

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 has a specific verb ('Check'), a clear resource ('robot's camera'), and a concrete method ('capturing a test frame'). This clearly distinguishes it from sibling tools like reachy_capture_image, which is about capturing an image rather than checking camera health.

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 case—verifying the camera works—is implied by the purpose, but there is no explicit guidance on when to choose this over reachy_capture_image or reachy_status, nor any stated exclusion conditions. The usage context is clear enough but not fully clarified.

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 absent, so the description bears full responsibility for behavioral disclosure. It does reveal that a short audio sample will be recorded, which is useful, but it does not explain what happens afterward—whether the sample is played back, analyzed, or simply used to return a pass/fail indication. The criterion for 'working' is left undefined.

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

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

The description is a single, compact sentence that front-loads the action and target and contains no filler. Every word contributes to explaining the tool's core 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?

The tool is simple—one optional parameter, no output schema, no annotations—and the description covers the main action and method clearly. However, because there is no output schema, the description should clarify what type of result the agent can expect (e.g., boolean, audio metrics, or a report), and that is missing. This creates a moderate gap for an agent trying to interpret the tool's response.

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

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

The schema already documents the only parameter, `duration`, with a description and default value (100% coverage). The description's phrase 'short sample' loosely aligns with the duration parameter but adds no new semantic meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Check') with a clear resource ('the robot's microphone') and the method ('by recording a short sample'). It distinguishes itself from sibling tools like reachy_check_camera and reachy_play_audio by targeting microphone health specifically.

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 description—verify the microphone by sampling—but there is no explicit guidance about when to choose this over alternatives such as reachy_list_audio or reachy_play_audio, and no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool retrieves status but does not mention return format, error behavior, or whether a connection/wake state is required.

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

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

The description is a single, direct sentence with no wasted words, making it concise and easy to parse. It is somewhat terse and generic, but for a parameterless tool this brevity is mostly appropriate.

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

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

Given the absence of an output schema and annotations, and the existence of overlapping sibling tools, this description is not complete enough. An agent cannot tell what fields will be returned or how this differs from reachy_status or reachy_get_state.

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 are no parameter semantics the description must clarify. The description therefore does not need to add input details beyond what the schema already conveys.

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

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

The description states a clear action ('Get') and a specific resource ('detailed motor status information'), so an agent knows the basic function. However, it does not explicitly differentiate this tool from siblings like reachy_status or reachy_get_state, which likely overlap in 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?

There is no guidance on when to use this tool versus reachy_status or reachy_get_state. The description implies it is for motor status, but no conditions, exclusions, or alternatives are provided.

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

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

No annotations are provided, so the description carries the transparency burden. It conveys a read operation and hints at returned data types, but it doesn't state whether the call is safe/read-only, whether it can fail, or whether the payload is large. This is adequate for a simple getter but not rich.

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

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

Single sentence, no filler, front-loaded with the action and object, and supported by concrete examples of the contents.

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

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

For a zero-parameter read tool with no output schema, the description covers the main return domains (joint positions, sensor data). It would be slightly stronger if it clarified what counts as 'full' state or noted a relationship to reachy_status, but nothing essential is missing for invoking it.

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

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

The tool has zero parameters, so there is no parameter semantics burden. The input schema is already complete and the description correctly focuses on behavior rather than 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?

Description uses a specific verb 'Get' and resource 'full robot state', and enumerates content (joint positions, sensor data). It is clear on its own, though it doesn't explicitly differentiate from similar siblings like reachy_status or reachy_get_motor_status.

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

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

No guidance on when to choose this tool versus alternatives such as reachy_status or reachy_get_motor_status. No context, prerequisites, or exclusions are provided.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only says 'execute sleep behavior' without explaining what that means for the robot's motors, state, or ability to be woken up. This is a significant gap for an action that likely has side effects.

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

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

The description is a single, short sentence that immediately states the action. It contains no unnecessary filler and is well structured for quick agent comprehension.

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

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

For a parameterless action this is minimally adequate, but the description does not mention what 'sleep behavior' entails, whther it is reversible, or what happens to the robot's state. Without annotations or an output schema, a bit more behavioral context would make it complete.

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

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

The tool has zero parameters and the schema already covers their absence completely. The description does not need to add parameter details, so the baseline of 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 description clearly states the action and target: 'Put the robot to sleep'. It distinguishes the tool from siblings like reachy_wake_up and reachy_go_to_zero by naming the specific sleep state the tool produces.

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

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

There is no explicit guidance about when to use this tool or when to prefer an alternative. The intended use is implied by the action and visible sibling tools, but the description itself does not state context, prerequisites, or 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?

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only says 'move the robot to zero/neutral position' but does not explain whether the motion is blocking, whether it requires a wake state, what happens if motors are disabled, or whether it cancels ongoing continuous moves. This is a significant gap for an action that moves a physical robot.

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 redundant or speculative information. It communicates the core action and target state 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-argument tool, this is minimally viable, but it lacks context around prerequisites and consequences. Given the rich sibling set (wake_up, go_to_sleep, continuous move tools), an agent would benefit from knowing whether the robot should be awake and whether this resets any ongoing 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, so there is no parameter documentation burden. The description adds no parameter detail, but none is needed in this case; the baseline of 4 is appropriate.

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

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

The description states a clear verb ('move') and a clear target ('zero/neutral position'), which distinguishes it from sibling tools like reachy_move_head or reachy_move_antennas. It is not a tautology, though it could be slightly more explicit about whether it affects all joints or a specific posture.

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

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

There is no guidance about when to use this tool versus alternatives such as reachy_wake_up or reachy_go_to_sleep. The description does not mention whether the robot must be awake, whether this is a reset action, or when an agent should prefer this over continuous movement tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It indicates a read-only listing operation and provides no hint of destructive side effects. However, it does not describe what the returned list contains, whether ordering/format is guaranteed, or whether robot connectivity is required. For a simple list tool this is adequate but not rich.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the tool's meaning, and there is no redundant restating of the name or parameters.

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

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

Given the tool's trivial parameter surface and simple listing behavior, the description is sufficient for an agent to select and invoke it correctly. It could add more detail about return format, but for a read-only list operation this is a minor gap.

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

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

The tool has zero parameters and 100% schema coverage, so there is nothing for the description to clarify. Per the baseline for zero-parameter tools, this dimension warrants a solid score.

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

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

The description uses a specific verb ('List') and a clear resource ('all saved audio recordings on the robot'). It is easily distinguished from sibling tools like reachy_play_audio or reachy_check_microphone because it is the only one scoped to enumerating saved recordings.

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

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

The description clearly conveys the tool's purpose: enumerate saved audio recordings. It does not explicitly mention alternatives or when-not-to-use, but the context is unambiguous enough that an agent can infer this is for listing rather than playing, capturing, or checking audio.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'move' without explaining behavior such as whether movement is absolute or relative, whether the robot must be awake first, whether the command blocks until completion, or what happens if a position is out of range. This is a significant gap for a physical motion tool.

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

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

The description is a single clear sentence with no redundant wording. 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?

Given the absence of annotations and output schema, the description should provide more context about preconditions, side effects, or expected results. The schema covers parameters well, but the tool lacks guidance on whether the robot must be awake, whether the movement is safe to call anytime, or what the agent should expect in response, leaving the context incomplete.

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

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

Schema description coverage is 100%, so the input schema already documents left, right, and duration with units and defaults. The description adds no new parameter semantics beyond the phrase 'specified positions', which is acceptable but does not elevate the score above the baseline.

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

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

The description states a specific verb ('move') and resource ('the robot's antennas'), making the tool's function immediately clear. It also distinguishes itself from sibling tools like reachy_move_head by targeting antennas specifically, not the head or other parts.

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 resource name implies this tool is for antenna movement, and sibling tools handle other body parts, so usage is inferable. However, there is no explicit guidance about when to use this tool versus alternatives like reachy_move_head, nor any mention of exclusions or prerequisites that would strengthen 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?

No annotations are provided, so the description carries the full burden. It duplicates the pitch/roll/yaw limits already present in the schema, but does not disclose whether the angles are absolute or relative, what happens if the robot is asleep, whether the motion blocks until completion, or error behavior. This is insufficient for a physical manipulation 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 short and front-loaded with the core action. However, the second sentence restates range constraints already present in the schema, making it slightly redundant rather than purely additive.

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

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

With no annotations, no output schema, and all parameters marked optional, the description leaves key questions unanswered: what happens when no orientation parameters are supplied, whether orientation is absolute or relative to the current pose, and how duration affects execution. An agent cannot infer correct invocation from the available information alone.

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

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

Schema coverage is 100% with per-parameter descriptions, so the baseline is 3. The description's range statement for pitch/roll/yaw adds no new meaning beyond what the schema already specifies; it does not clarify the role of duration or how 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 states a specific verb and resource: 'Move the robot's head to a specific orientation.' This clearly distinguishes it from siblings like reachy_move_antennas, which concerns a different body part. The range limits also add specificity to what the 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?

The description implies its use case ('move the robot's head') but gives no explicit guidance on when to choose this over alternatives, nor any exclusions or prerequisites like waking the robot first. With multiple sibling tools for movement (antennas, continuous move, go_to), this could be clearer.

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 states the observable behavior (audio playback through the robot's speaker), but does not disclose whether playback blocks, whether the file must already exist on the robot, or how failures are reported.

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. Every word earns its place for such 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?

The tool is simple and the schema covers the only parameter, but because there are no annotations and no output schema, the description should at least hint at prerequisites or the relationship to reachy_list_audio. It is adequate but leaves operational details to be discovered.

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

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

Schema description coverage is 100%, so the parameter is already adequately documented as 'Name of the audio file to play'. The tool description adds no operational details about file location, format, or how to obtain valid filenames.

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: 'Play an audio recording through the robot's speaker'. It clearly separates this tool from the sibling list_audio and the movement/camera/streaming 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 intended use is implied by the action verb, but the description gives no explicit when-to-use guidance or comparison with alternatives. It also does not mention that reachy_list_audio is the companion tool for discovering valid filenames.

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 exist, so the description must disclose behavioral effects. 'Try to reconnect' gives only the intent and does not explain consequences: whether it is safe, whether it blocks, whether it affects the robot's state, or what happens if already connected. This is a meaningful gap for a tool that mutates connection state.

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 dscription is a single, front-loaded sentence with no filler. It could be slightly improved by removing the hedging 'Try', but for a zero-parameter tool it is concise and to the point.

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 no annotations, no output schema, and no parameter documentation burden, the description should explain when to call it and what to expect. It only states intent. Given the sibling set includes status checks and wake/sleep operations, an agent needs more context to know when reconnect is the right call and what it actually does.

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

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

The tool has zero parameters and the schema documents all of them trivially. The description doesn't need to explain parameters, and it doesn't contradict or confuse the empty schema. 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 dscription states a specific action — reconnect — and a target resource — robot demon. This clearly undestands the tool's purpose and distingishes it from siblings such as status, wake_up, or move_head. Even though it does not name an alternative, the action is unique among the 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?

No guidance is provided about when to use this tool instead of others. It does not mention detecting a lost connection, checking status first, or any prerequisite conditions. The only implication is that 'reconnect' means use it after connection failure, but that is left to inference.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that the movement is continuous and sinusoidal, which is a meaningful behavioral trait. However, it does not state whether the movement continues until stopped, what happens if the robot is asleep, or any 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?

The description is a single concise sentence with the key verb and object front-loaded. There is no redundant or extraneous 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 tool, the description names the action and the movement type, but it leaves important context implicit: which joint group or motors are affected, whether stop_continuous_move is the intended counterpart, and whether any precondition like wake_up is needed. An agent could call it reasonably, but not with full confidence about scope and effects.

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

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

The input schema has zero parameters and 100% schema description coverage by default. There are no parameters whose semantics need explanation, so the baseline of 4 is appropriate.

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

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

The description identifies a specific action ('start') and a specific resource ('continuous sinusoidal movement on the robot'). It is distinguishable from sibling tools like stop_continuous_move and move_head, though it does not specify which body parts are involved.

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 instead of sibling tools such as move_head or move_antennas. The existence of stop_continuous_move implies a pairing, but the description does not clarify scope or conditions.

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

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

No annotations are provided, so the description carries the full burden. It discloses that streaming starts, the sources involved, and that a URL is returned. However, it does not mention that the stream continues until explicitly stopped, nor any side effects like replacing an existing stream or resource usage, which would be relevant for a stateful start operation.

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

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

Two short sentences, front-loaded with the action and result. There is no filler, repetition, or unnecessary detail.

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

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

For a zero-parameter tool, the description adequately covers the invocation and return value (the stream URL). It omits lifecycle guidance such as how to stop the stream or verify it is running, but sibling names provide some of that context.

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

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

The input schema is empty, so there are no parameters to document; per baseline a 0-parameter tool rates 4. The description adds relevant context about which sources are streamed, but no parameter-specific explanation is needed.

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

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

States a specific verb ('Start') and resource ('WebRTC video/audio streaming from the robot's camera and microphone'), and explicitly says it returns the stream URL. This clearly distinguishes it from sibling tools like reachy_stop_webrtc_stream and reachy_capture_image.

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

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

The description implies usage when the agent wants to begin streaming, but it gives no explicit guidance on when to prefer this tool over alternatives or on prerequisites such as camera/microphone readiness. There are no exclusions or references to related tools like reachy_stop_webrtc_stream for cleanup, so usage context 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?

With no annotations provided, the description carries the burden of signaling safety. The verb 'Get' implies a read-only operation, but the description does not disclose return format, failure behavior, or whether invoking it may trigger any background connection checks. It is minimally transparent but not richly descriptive.

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 meaning, and the core resource ('daemon health status and robot connection info') is 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?

For a zero-parameter status tool with no output schema, the description gives a reasonable high-level account of what the caller receives: daemon health status and connection info. It is sufficient for selecting and invoking the tool, though more detail about the exact health/connection fields would be needed for deeper completeness.

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

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

The tool has zero parameters and an empty input schema, so there are no parameter semantics to clarify. The baseline for zero parameters is 4, and the description adds no unnecessary parameter-related noise.

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 ('Get') and clearly identifies the resource: 'Reachy Mini daemon health status and robot connection info'. This distinguishes it from sibling tools like reachy_get_state (robot state) and reachy_get_motor_status (motor-specific status), even without naming 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?

The description provides no guidance on when to use this tool versus alternatives such as reachy_get_state, reachy_get_motor_status, or reachy_webrtc_stream_status. It states what the tool does but gives no context about appropriate use cases or 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?

The description accurately states the direct effect: stopping continuous movement. However, with no annotations supplied, the description carries the full behavioral burden and does not disclose side effects, idempotency, blocking behavior, or whether motors are disabled.

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 six-word sentence with a direct subject-verb-object structure. It is front-loaded, contains no filler, and every word contributes to 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 zero-parameter, no-output-schema command, the description contains the essential information an agent needs: what action is performed and on what resource. It would benefit from a brief usage note about when to stop continuous movement, but the current scope is largely 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 has zero parameters and an empty input schema, so there is nothing for the description to explain. The description appropriately avoids inventing parameter details, meeting the baseline for parameterless tools.

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

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

The description states a clear verb-resource pair: 'Stop continuous movement' on the robot. This precisely identifies the operation and naturally distinguishes it from sibling tools like reachy_start_continuous_move, though it does not 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?

There is no guidance about when to use this tool versus alternatives such as reachy_go_to_zero, reachy_wake_up, or reachy_go_to_sleep. The only usage signal is the implied scenario of continuous movement being active, but no prerequisites or conditions are stated.

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

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

With no annotations, the description carries the burden of behavioral disclosure, and it does state the core side effect: the WebRTC video/audio stream is stopped. It does not disclose edge-case behavior such as idempotency, whether an active session is required, or whether the underlying connection is closed.

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

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

The description is a single, front-loaded sentence with no redundant words or restatement of the tool name. Every word contributes to the action and the target resource.

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 control command with no output schema, the description is nearly complete: it names the operation and the resource affected. The only gaps are minor operational details such as error or state-handling 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 takes zero parameters and the schema coverage is 100%, so there are no parameter semantics for the description to add. The 0-parameter baseline of 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 description uses a specific verb ('Stop') and names the exact resource ('WebRTC video/audio stream on the robot'). This clearly distinguishes it from the sibling tools start_webrtc_stream and webrtc_stream_status without needing to inspect any schemas.

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: call this when the robot's WebRTC stream should be ended. However, the description does not state whether it should follow a successful start, whether it is safe to call when no stream is active, or mention alternatives like webrtc_stream_status.

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

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

No annotations are provided, so the description bears full responsibility for disclosing behavior. It merely restates the concept of waking up and provides no detail about physical movement, duration, blocking behavior, side effects, or failure conditions.

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

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

The description is a single compact sentence with the key verb front-loaded. The phrase 'execute wake up behavior' is slightly redundant, but the overall size is appropriate.

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 command, this is minimally viable: the agent knows what the tool does. However, with no output schema and no annotations, the description leaves out expected side effects and operational context, so it is not fully complete.

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

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

There are zero parameters and an empty required list, with schema coverage at 100%. No parameter documentation is needed, so the description does not need to compensate for missing parameter semantics.

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

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

The description uses a specific verb ('Wake up') and a clear resource ('the robot'), making the tool's action unmistakable. It does not explicitly distinguish itself from siblings, though it is logically the opposite of reachy_go_to_sleep.

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 call this tool, what conditions should hold first, or how it compares to alternatives such as reachy_go_to_sleep or reachy_reconnect. The only implied usage is that waking up precedes robot interaction, but this is left to inference.

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

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

With no annotations provided, the description carries the full burden. The wording 'check if ... currently running' clearly conveys a read-only, non-mutating status query and promises the stream URL as the result. It does not spell out read-only semantics explicitly, but the verb and 'currently' make side effects unlikely.

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, no filler, with the action and the returned value both 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 low-complexity, zero-parameter status tool the description covers purpose and the result it returns. There is no output schema or annotation to lean on, so a slightly more explicit return format (e.g. what is returned when the stream is not running) would make it fully complete, but the current description is nearly 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 has zero parameters and 100% schema coverage, so there is nothing for the description to add about argument semantics. The baseline of 4 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 states a specific action ('check if WebRTC stream is currently running') and an output ('get the stream URL'), with a clear resource ('WebRTC stream'). This distinguishes it from siblings like reachy_start_webrtc_stream and reachy_stop_webrtc_stream, which are action-oriented rather than status-oriented.

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

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

The usage context is implied by the name and the 'currently running' phrasing: use it to inspect stream state rather than start or stop the stream. However, it does not explicitly state when to prefer this tool over reachy_status or mention alternative tools, so the guidance is left to inference.

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