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, but it only says 'Play a named animation.' It does not disclose whether the tool blocks until completion, what happens to ongoing robot behavior, durability of the animation, or any side effects beyond the action itself.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes directly to the tool's purpose, making it easy to parse quickly.

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

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

For a one-parameter tool with full schema coverage, the description is minimally sufficient for basic invocation. However, it lacks usage guidance and behavioral context, and the absence of an output schema means the agent gets no hint about return values or failure modes.

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

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

The schema covers 100% of parameters and already provides an example identifier, so the baseline is 3. The description adds minimal extra meaning beyond restating that the animation is named; it does not clarify where valid names come from or how the identifier is interpreted.

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 ('Play'), a specific resource ('a named animation'), and the target ('on the robot'). It clearly distinguishes the tool's purpose from siblings like vector_drive or vector_say, though it does not explicitly contrast it with visually similar animation-related actions.

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

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

The description gives no indication of when to use this tool versus alternatives, no prerequisites, and no exclusions. An agent is not told whether this is for one-shot effects, looping animations, or how it relates to other action tools like vector_look or vector_head.

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 disclosure burden. It clearly states the core action and underlying API call, but it does not mention side effects, blocking behavior, return format, or whether the robot state is modified. This is adequate for a zero-parameter read-like capture, but leaves some behavioral details unstated.

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

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

The description is a single front-loaded sentence that states the action, resource, and API method with no wasted words. It is concise without sacrificing essential 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 parameterless, single-action tool, the description is largely complete: it tells the agent what to invoke and what to expect conceptually. It could be more explicit about the returned frame format, but its simplicity and lack of parameters keep the omission minor.

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

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

The input schema has zero parameters, so there is no semantic ambiguity to clarify. The description adds nothing beyond the schema, but nothing is needed; the baseline of 4 for a parameterless 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 uses a specific verb, 'Capture', and a clear resource, 'a single camera frame', with the exact API method named. This unambiguously distinguishes it from vision-analysis siblings like vector_find_faces and vector_face_detection.

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. It does not mention cases where vector_scan, vector_look, or other vision tools would be more appropriate, so the agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full transparency burden. 'Return' signals a read-only query and it names what is returned, but it does not state error behavior, side effects, or what the state includes. This is acceptable for a simple status fetch but still minimal.

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

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

Six words, no filler, and the main verb is front-loaded. Every word contributes meaning, making it appropriately concise for a zero-parameter status tool.

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

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

For a parameterless status tool, the one-liner tells the agent what domain it covers, but with no output schema the description should be more specific about what fields constitute 'charger and battery state.' It is adequate as a high-level description, 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 accepts zero parameters, so there is no parameter documentation burden. The description correctly focuses on the output 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?

The description uses a specific verb ('Return') and names the resource ('charger and battery state'), which distinguishes it from broader sibling tools like vector_status or vector_proximity_status. However, 'state' is left vague and the description does not explicitly contrast itself with 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 instead of vector_status or other status siblings. The name and phrase 'charger and battery state' imply the context, but no alternatives 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 present, so the description carries full responsibility for behavioral disclosure. It reveals nothing about the effects of dock, pickup, drop, or roll, whether the operations are safe, what preconditions exist (e.g., cube must be nearby), or what the robot will do after each action.

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

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

The description is a single efficient sentence with no redundant words. It clearly identifies the target resource, which earns its place, though it sacrifices substance for brevity.

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

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

For a simple one-parameter tool the description is not complete enough. It fails to explain the semantics of each enum value, expected side effects, or any prerequisites, and there is no output schema to clarify what the tool returns. An agent would need to guess at the behavior of physical cube actions.

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

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

Schema description coverage is 100% for the single 'action' parameter, including an enum and a basic description. The tool description adds no additional meaning beyond what the schema already provides, so the baseline of 3 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 identifies the resource ('Vector's cube accessory') but uses the vague verb 'Interact' instead of naming specific operations. It does not distinguish this tool from siblings like vector_lift or vector_head, so an agent must rely on the schema to infer what the tool actually does.

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

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

No guidance is given about when to use this tool versus alternatives. With 23 sibling tools covering physical actions, the description provides no context for choosing vector_cube over tools like vector_drive, vector_lift, or vector_head.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and does not reveal side effects, prerequisites, or limitations (e.g., whether the robot must be off the charger, if it stops on obstacles, or if it blocks until completion). This is a significant gap for a physical motion command.

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 every word earning its place. It communicates the essential action without fluff, making it easy for an agent to parse quickly. This is an example of efficient conciseness.

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

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

For a simple, three-parameter tool with full schema coverage, the description is minimally adequate. The agent knows what the tool does and the parameters are documented, but it lacks context about safe usage (e.g., obstacles, charger states) and when it is appropriate versus siblings. Given the existence of vector_drive_on_charger, some additional context would help, but the tool is simple enough that a 3 seems fair.

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 baseline is 3. The description adds no additional semantic meaning beyond the schema; it does not explain how speed, angle, and distance interact or that they are optional. The schema already provides units and defaults, so the description is not necessary for parameter understanding.

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

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

The description clearly states the action: 'Move the robot straight and/or turn it in place.' It specifies the verb and resource, so an agent understands the core function. However, it does not differentiate from sibling tools like vector_drive_on_charger, which might have overlapping use cases, so it's not 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, prerequisites, or exclusions. For example, it does not clarify when vector_drive_on_charger would be more appropriate, leaving the agent to infer context from the sibling list alone.

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

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

With no annotations provided, the description carries the full responsibility for behavioral disclosure. It does not state whether the robot physically moves, whether the command can fail (e.g., if not on charger), or any safety considerations. This is a minimal action description with no added behavioral context.

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

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

A single, perfectly front-loaded sentence with zero wasted words. Every element 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 parameterless command with no output schema, the description is nearly complete—it states the exact action. However, the lack of any usage guidance or non-obvious prerequisites (e.g., must be on charger for this to make sense) leaves a small gap for an agent deciding whether to call 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 and schema coverage is 100%, so the baseline for 0 params is 4. The description doesn't need to explain parameter meanings because none exist, and it adds no confusion.

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 'Drive the robot off its charger' uses a specific verb and resource, clearly distinguishing it from the sibling vector_drive_on_charger and other movement commands. An agent can immediately identify the tool's purpose without needing to inspect 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 given on when to use this tool versus alternatives, such as when the robot must already be on the charger or how it relates to vector_drive_on_charger. The expected usage context is implied by the name but never stated, leaving the agent to infer prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It transparently discloses the immediate return condition, the prerequisite for the charger in the world model, and the motor-stop fallback behavior on timeout. This goes far beyond a generic 'drive' statement and gives the agent a realistic model of 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?

Three concise, well-ordered sentences cover the core action, immediate-return behavior, prerequisite, and fallback. No filler or redundant restating of the tool name; every sentence contributes 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?

With no output schema, the description explains the early-return value and the timeout fallback, which are the main non-obvious behaviors. It does not specify the exact return value for the normal successful drive, but an agent has enough context to invoke the tool correctly and understand its failure mode.

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 already documents timeout_sec with type, default, and bounds. The description adds behavioral meaning by explaining that the timeout triggers a best-effort motor-stop fallback, which is not present in the schema. This enriches the parameter's purpose.

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: drive Vector back onto its charger, with a configurable timeout. This clearly distinguishes it from related tools like vector_drive_off_charger and generic vector_drive by focusing on docking behavior.

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

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

Provides an explicit precondition: the charger must be in Vector's recent world model, and directs the agent to use vector_scan first if not. It also describes the immediate early-return case. It does not enumerate alternative docking methods, but the guidance is clear enough for selection.

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

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

With no annotations provided, the description carries the full behavioral burden. It clearly communicates an immediate, global halt of all motors, which is the core behavioral trait. It does not mention side effects or prerequisites, but for a no-argument emergency stop the essential behavior is explicitly 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?

The description is a single, seven-word sentence with zero filler. 'Immediately' and 'all motors' are placed at the start, making the purpose and scope instantly clear.

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

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

For a no-argument tool with no output schema, the description is nearly complete: it names the action, the resource, and the immediacy. It lacks explicit guidance on when to prefer this over normal drive commands, but invocation requires no parameters and the core semantics are fully specified.

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

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

The input schema defines zero parameters, so schema coverage is trivially 100% and no parameter documentation is needed. The description adds nothing parameter-specific, but none is required. A baseline of 4 applies for a zero-parameter tool.

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

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

The description states a specific verb and resource: 'Immediately stop all Vector motors.' It clearly differentiates this tool from movement-related siblings by emphasizing 'stop' and 'all motors,' leaving no ambiguity about what it 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 word 'Immediately' and the tool name 'emergency_stop' imply this is for urgent halting, but the description never explicitly says when to use it or what alternatives exist for normal stopping. An agent can infer the urgency context but is not given explicit guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action and screen dimensions. It does not mention side effects such as replacing current face/animation, whether the image must be exactly 144×108 or will be resized, or what happens after the duration expires.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the action, target, and a useful resolution constraint in minimal space.

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

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

For a simple two-parameter tool the description and schema provide the core calling information. However, the lack of output schema, annotations, image format constraints, and behavioral side effects leaves clear gaps for an agent deciding whether and how to invoke the tool.

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

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

Schema description coverage is 100%, and the schema already explains both image_base64 and duration_sec. The description adds only that the image is custom and the target is the face screen, which is not needed to understand the parameters.

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

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

The description states a specific verb ('Display') and resource ('the robot's face screen') and adds a helpful constraint (144×108). This clearly distinguishes it from sibling animation and vision tools, so an agent can understand its purpose without opening the schema.

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

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

There is no guidance about when to use this tool versus alternatives like vector_animate or vector_face_detection. The description implies the use case from its wording but offers no explicit context, exclusions, or alternative routing.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the output is a summary rather than raw image data, but it says nothing about side effects, whether this is a live snapshot, or how empty results are returned.

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

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

A single, front-loaded sentence with no filler. The core return promise and the important 'no raw image data' exclusion are both present with minimal wording.

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

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

For a zero-parameter read-style tool, the description is nearly sufficient: it tells the agent what it returns and what it omits. It lacks detail about the summary structure and does not differentiate from sibling tools, leaving minor ambiguity.

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 is an empty object with zero parameters, so the baseline for parameter semantics is 4. Since there are no parameters to document, the description need not add parameter-specific detail.

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

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

The description clearly states the action ('Return a summary') and resource ('currently visible faces'), and explicitly excludes raw image data. It is slightly weakened by not naming or distinguishing the sibling tools like vector_list_visible_faces or vector_find_faces.

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 the many similar sibling vision tools. The 'no raw image data' qualifier gives an implicit selection clue, but no explicit when/when-not or alternative is provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that Vector will 'actively search,' but does not say whether this is blocking, how long it lasts, whether it interrupts other behaviors, what side effects occur, or how results are observed. This is a significant gap for an action-oriented 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 the action and object front-loaded. There is no wasted detail, and it is appropriately sized for a zero-parameter tool.

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

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

Although the tool has no parameters, it has nontrivial behavioral implications and sits among many vision-related siblings. The description does not mention how results are retrieved, whether the search runs in the background, or any conditions around invoking it, so an agent lacks enough context to use it effectively.

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

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

The tool has zero parameters, so the schema is trivially fully covered and the description does not need to explain arguments. The baseline of 4 applies because there is nothing missing parameter-wise.

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 ('actively search') with a clear target ('faces in the environment'), so an agent understands what the tool does. However, it does not explicitly distinguish this from related siblings like vector_face_detection or vector_list_visible_faces, so differentiation must be inferred.

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 vector_face_detection, vector_list_visible_faces, or vector_scan. The description implies an active search mode but provides no prerequisites, exclusions, or context for choosing it over siblings.

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

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

With no annotations, the description carries the behavioral burden. It explicitly discloses clamping to the safe range (-22.0 to 45.0 degrees), which is the most important behavioral trait. It could mention whether the call blocks until movement completes, but the disclosed behavior covers the core safety-critical aspect.

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 uses two short, information-dense sentences with no filler. The operation is front-loaded, and the clamping behavior is stated immediately afterward.

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

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

For a single-parameter actuator with full schema coverage and no nested objects or output schema, the description gives an agent enough to invoke the tool correctly. It could add failure or async behavior details, but they are not essential for basic correct usage.

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

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

Schema description coverage is 100%, so the input schema already fully documents angle_deg including units, range, and clamping. The description restates this information but does not add new semantic 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 precise verb and resource: 'Set Vector's head angle in degrees.' It also includes the exact safe range, making it immediately clear what the tool does and distinguishing it from siblings like vector_lift or vector_drive.

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 is clear: an agent should use this tool when it needs to change Vector's head angle. It does not explicitly name alternatives or exclusions, but the focused scope makes the usage context unmistakable.

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

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

With no annotations provided, the description carries the full burden. It does disclose the clamping behavior ('Input is clamped to the valid range 0.0–1.0'), which is useful. However, it omits other behavioral aspects such as whether the operation is asynchronous, whether it blocks, or any safety implications of moving the physical lift. The provided info is accurate but limited.

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

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

The description is a single sentence with no redundant words. It front-loads the action, then specifies the range and clamping behavior. Every word earns its place, making it highly efficient.

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

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

The tool is simple with one parameter and no output schema, so the description is mostly adequate. However, given it physically moves a robot component, it might benefit from mentioning that the movement is not instantaneous or that it may fail if the robot is not in a stable state. The description covers the core behavior but lacks such contextual details, leaving some potential gaps for an agent.

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

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

The schema already describes the parameter well (100% coverage), so the baseline is 3. The description adds value by explicitly defining the endpoint meanings (0.0 = lowest, 1.0 = highest), which the schema only calls 'normalised value'. This clarifies the semantic range beyond the schema, justifying a 4.

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

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

The description clearly states the tool's action ('Set Vector's lift/arm height') and provides the specific range with semantic meaning (0.0 lowest, 1.0 highest). It is not a tautology and effectively distinguishes this tool from siblings that control other robot functions (e.g., vector_head, vector_drive).

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 is implied: the tool is for setting the lift height, which is self-evident. However, there is no explicit guidance on when to use this versus alternatives, no mention of prerequisites (e.g., robot must be connected), or conditions under which this should not be used. The context is minimal but not misleading.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It essentially restates the tool name and does not explain what a returned face looks like, whether an empty list is possible, whether this triggers detection, or whether the operation has side effects. The temporal scope 'currently visible' adds minimal value but not enough for real 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?

A single, direct sentence that front-loads the action and the resource. There is no filler, repetition, or unnecessary detail, making it efficiently scannable for an agent.

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

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

For a zero-parameter query tool, the description is minimally adequate: an agent can invoke it without arguments. However, since there is no output schema, the description should clarify what the returned list contains (e.g., face IDs, names, confidence scores) and whether an empty list is a valid result. This missing return-value context leaves a moderate 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 is empty, so the baseline is 4 because there is nothing for the description to clarify. The description correctly implies that no arguments are needed, and no further parameter-level meaning is required.

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

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

The description clearly states the verb ('Return') and resource ('list of faces currently visible to Vector'). It is unambiguous about what the tool does, but it does not explicitly differentiate itself from similar siblings like vector_list_visible_objects or vector_find_faces, so it misses the full sibling-differentiation bar.

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 stated guidance on when to use this tool versus alternatives. For example, it does not explain when to prefer this over vector_find_faces (which likely actively searches) or vector_face_detection. The phrase 'currently visible' implies a passive snapshot, but no explicit context 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 the full burden of behavioral disclosure. It only states the action without revealing side effects, read-only nature, or behavior when no objects are visible. This is minimal information beyond the obvious, lacking any caveats or additional context.

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

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

The description is a single concise sentence with no unnecessary words. It front-loads the action immediately and is appropriately sized for the trivial nature of the tool.

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

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

For a simple no-parameter tool, the description is adequate but lacks nuance about return format or edge cases such as empty lists or object types. Without an output schema, a bit more context would have been valuable, though the simplicity of the tool mitigates the 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, so schema coverage is 100% by definition. The description adds nothing about parameters because there are none to explain. The baseline of 4 applies due to the absence of parameters, and no information is missing.

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 (Return) and resource (list of objects visible to Vector). It distinguishes from sibling vector_list_visible_faces by referring to objects generally, though it does not explicitly contrast. The purpose is clear and 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or recommended scenarios. It merely states the action without contextualizing it among the sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the core action. It does not mention side effects (e.g., whether the head moves), prerequisites (e.g., whether the camera must be enabled), or what happens after capture (returned image, saved file, etc.).

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 communicates the essential operation with no filler. Every word is useful and the structure is immediately scannable.

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

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

For a parameterless tool, the description minimally conveys what happens, but it is incomplete in context because the sibling list contains vector_capture_image, which likely overlaps in function. It also does not state the output form or any caveats, though the lack of an output schema leaves some latitude.

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, so there is no parameter documentation burden. The description correctly avoids inventing parameters and needs to convey no additional parameter-level 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 states a specific action ('capture an image') and a concrete resource ('the robot's front camera'), so an agent can understand the basic operation. However, it does not differentiate this tool from the sibling vector_capture_image, which appears to have the same purpose, so it falls short of full clarity.

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

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

No guidance is given about when to use vector_look versus alternatives such as vector_capture_image or vector_scan. The description only states what the tool does, not when it should be chosen or what conditions apply.

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 and no output schema, the description carries the full burden. It says the tool returns current position and orientation, but does not disclose units, coordinate frame, or response structure. This is adequate for a simple getter but not richly transparent.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to conveying the tool's purpose.

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

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

For a zero-parameter, no-output-schema tool, the description adequately states what the tool returns (position and orientation). It is complete enough for tool selection and invocation, though it omits return format details that could help an agent parse the result.

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

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

The tool has zero parameters, and the schema coverage is effectively complete. Since there are no parameters needing explanation, the baseline of 4 applies and the description adds no unnecessary parameter detail.

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

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

The description clearly states a specific read operation: getting the robot's current position and orientation. It is unambiguous but does not explicitly distinguish itself from sibling tools like vector_status, so it falls short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives. The description does not mention conditions, exclusions, or why this tool is preferable to related status/pose 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 of behavioral disclosure. 'Return' clearly implies a read-only query, but the description does not disclose output units/range, whether the reading is live or cached, or how an unavailable sensor reading would be represented.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It is appropriately sized for a zero-parameter sensor-read 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?

Invocation is trivial because the tool takes no parameters. However, there is no output schema and the description does not characterize the returned 'reading' — for example, units, value type, or possible states — leaving a gap for interpreting the result.

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

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

The input schema has zero properties and schema description coverage is 100%, so there are no parameter semantics for the description to clarify. The baseline 4 applies for a 0-parameter tool.

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

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

The description uses a specific verb ('Return') and a specific resource ('proximity sensor reading from Vector's front IR sensor'), naming the exact sensor. This clearly differentiates it from siblings like vector_touch_status, vector_charger_status, and the generic vector_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?

The use case is implied: an agent should call this when it needs the front IR proximity reading. However, there is no explicit guidance about when to prefer this over vector_status or other sensor-related siblings, and no exclusions 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It states that the robot speaks text but remains silent on key aspects such as whether the action is blocking, asynchronous, dependent on robot state, or returns any status. This is a minimal behavioral description with no extra context.

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

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

The description is a single, front-loaded sentence with zero unnecessary words. It is appropriately sized for the tool's simplicity and conveys the essential action without redundancy.

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

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

For a tool with a single parameter, no output schema, and no annotations, the description covers the core action but omits important context such as the return value, potential side effects, or whether the action blocks. Given the simplicity, this is adequate but not fully complete. The agent might need to know if the call is asynchronous or returns a success indicator.

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 already fully documents the single parameter (text) with a description: 'Text for the robot to speak.' The tool description essentially repeats this information. Since schema coverage is 100%, the description adds no additional meaning beyond what the schema provides, so the baseline 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 clearly states the action (speak), the resource (text), and the subject (Anki Vector robot). It effectively distinguishes itself from the sibling tools, which are all about movement, sensing, or state changes. A single sentence is sufficient to convey the tool's purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or conditions that would help an agent decide between this and other robot-control tools. The agent has to infer from the name and description alone.

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

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

Annotations are absent, so the description carries the behavioral burden. It discloses that the robot remains in place and performs a scanning action, which is useful, but it does not specify duration, return value, or whether the scan uses the camera or other sensors.

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 communicates the action and its purpose with no filler. Every word earns its place.

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

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

For a zero-parameter, no-output-schema robot command, the description is largely sufficient for an agent to select and invoke it. A brief note about return values or completion behavior would make it fully complete, but the simple interface limits the gap.

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

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

The input schema has zero parameters, so the baseline is 4. The description correctly implies that no arguments are needed and adds no conflicting parameter expectations.

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 ('look around') and resource ('environment'), with 'in place' adding a spatial constraint. It is clear enough to distinguish from sibling tools like vector_drive, though it does not explicitly name the difference from vector_look.

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 'to scan the environment' implies a use case, but the description gives no explicit guidance on when to choose this tool over vector_look or other vision-related siblings. There are no exclusions or alternative routing hints.

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 behavioral disclosure burden. It does so well by surfacing mutating actions ('install the Vector SDK if missing', 'write OpenClaw config') and by stating the return shape: a structured PASS/FAIL report with remediation steps. It could add side-effect warnings, but the main behaviors are transparent.

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

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

Three focused sentences: pipeline, return value, and when to call. Every sentence earns its place and the most important usage instruction is front-loaded.

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

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

For a 6-parameter setup tool with no output schema and no annotations, the description is quite complete: it covers the workflow, the expected report, and the invocation context. It could mention edge cases like all flags being false, but the schema and description together give a capable agent enough to proceed.

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%, so the baseline is 3. The description's stage list loosely maps to the boolean flags (install_sdk, write_config, run_connectivity, run_smoke), but the schema already explains each parameter clearly and the description adds no parameter-level details beyond that.

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

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

The description names a specific verb ('Run') and resource ('VectorClaw setup wizard') and lists concrete pipeline steps: validate Python, install SDK, write config, check connectivity, run smoke tests. This clearly differentiates it from sibling robot-control tools like vector_drive or vector_say.

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 gives an explicit trigger and ordering: 'Call this tool first when setting up VectorClaw for a new user.' It does not name alternatives or exclusions, but the setup intent is unambiguous and unique among the sibling tools.

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

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

With no annotations, the description carries the burden of conveying that this is a read-only status query. The verb 'Get' strongly implies a non-mutating operation, and the examples reinforce that it returns status information. However, it does not disclose potential failure modes, connection requirements, or whether any side effects exist, though for a status read these are less critical.

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 main action and resource. It provides useful examples without unnecessary detail, making it easy for an agent to parse quickly.

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

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

For a no-parameter, no-annotation, no-output-schema tool, this description is largely sufficient: it names the tool's purpose and gives representative fields. It could be slightly more complete by noting that it returns a general status snapshot rather than a single status category, but the low complexity keeps the gap minor.

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

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

The tool has zero parameters, so parameter semantics are effectively irrelevant. Per the baseline for zero-parameter tools, the description need not explain parameters, and it does not need to compensate for any schema gaps.

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

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

The description clearly states a specific verb ('Get') and resource ('robot status'), with concrete examples like battery level and charging state. It does not explicitly distinguish itself from sibling status tools such as vector_charger_status or vector_proximity_status, but the general scope is understandable.

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

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

The description gives no guidance on when to use this tool versus the many sibling status tools (charger_status, touch_status, proximity_status). It only states what the tool does, leaving the agent to infer when to select it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a read operation but does not explain the return format, potential error states, or whether the reading is instantaneous. For a simple sensor read, this is minimal but not misleading; however, more detail would be beneficial.

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

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

The description is a single sentence that front-loads the action ('Return') and the specific resource. It contains no fluff and is immediately understandable.

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?

Since there is no output schema, the description should explain what the reading looks like (e.g., boolean, integer, threshold value). It does not, leaving some ambiguity for an agent that needs to interpret the result. For a parameterless sensor read, this is a minor gap but prevents full 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?

With zero parameters, the baseline is 4. The description adds no parameter information, but none is required since the tool takes no arguments. The schema already covers everything trivially.

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

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

The description uses a specific verb 'Return' and a clear resource 'touch-sensor reading from Vector's back capacitive sensor'. This unambiguously identifies the tool's purpose and distinguishes it from sibling status tools like proximity or charger, which operate on different sensors.

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

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

No guidance is provided on when to use this tool versus alternatives. It simply states what it does without any context about selection criteria, prerequisites, or when it might be preferred over other sensor reads.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states the primary effect ('Disable all active vision modes') but does not disclose whether the action is reversible, what happens when no modes are active, or any other side effects. This is minimal for a mutating tool.

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

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

The description is one concise, front-loaded sentence that states the action and the underlying method. It contains no filler or redundant 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 minimally viable, but it lacks context around when to use it, what counts as an 'active vision mode,' and what the outcome means for subsequent robot operations. Given no annotations or output schema, the description is somewhat thin.

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 confirms this. Baseline for zero parameters is 4, and the description correctly focuses on behavior rather than parameter details.

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

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

The description uses a specific verb and resource: 'Disable all active vision modes.' It clearly distinguishes this from vision-related siblings like vector_capture_image or vector_face_detection, though it does not explicitly name alternatives. The internal reference 'vision.disable_all_vision_modes' reinforces intent.

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, and it does not mention any prerequisites or side effects. An agent is left to infer that this is for disabling active vision modes.

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