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

With no annotations, the description carries the full burden and does well: it discloses the clustering input, lidar-based deduplication, the publish target, and the fact that geometry rather than a parameter determines the result. It stops short of describing stateful details such as whether looks are consumed or reset, but these are not critical for a zero-parameter 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?

Three short sentences, with the core action first and supporting clarifications after. Every sentence adds value and the '4, not 8' example is worth more than a longer explanation.

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 enough that this description is nearly complete: input is empty, output schema already exists, and the dedup behavior is explained. The only gap is not making the prerequisite explicit ('call this after completing count_in_view looks'), though that is strongly implied by the first sentence.

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 no parameters, and the description adds a meaningful clarification that the count is not passed by the caller ('You do not pass the number — geometry does'). This goes beyond the empty schema by explaining why the schema is empty, so the baseline-4 case is fully met.

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 precise operation ('Cluster every count_in_view look by lidar position') and a concrete output ('publish one integer on /numerical_response'). The dedup example ('4, not 8') makes the behavior unmistakable and distinguishes it from a raw counter like count_in_view.

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

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

It clearly situates the tool after one or more count_in_view looks and tells the agent not to supply a count ('You do not pass the number'). It does not explicitly name excluded alternatives, but the context is clear enough for an agent to know this is the aggregation/dedup step.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool does not return a running total, that instances are boxed and lifted for de-duplication, and that there is a 'sufficient' flag that controls further actions. It doesn't explicitly state side effects or read-only nature but the de-duplication behavior is a meaningful disclosure.

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

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

The description is a single paragraph with several sentences, each adding a distinct piece of information: the scope, the de-duplication mechanism, the sufficient flag handling, and the follow-up tool. It is front-loaded with the primary purpose and not unnecessarily verbose.

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

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

While an output schema exists (not visible here), the description does not explain what 'sufficient' is, what the return structure is, or what the parameters mean. It references 'next_view' and 'commit_count' but these are sibling tools that may or may not be self-explanatory. Missing parameter semantics leaves the agent guessing.

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

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

Schema description coverage is 0% and the description does not explain any of the three parameters (anchor, target, question). It references 'anchor' in passing ('ground the anchor') but never defines it, and does not clarify what 'matching' refers to or what 'target'/'question' mean. The agent must rely on the schema alone, which has no descriptions.

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

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

The description immediately states the core action: 'Count matching instances from the current vantage point only.' This is a specific verb with a clear resource scope, and it distinguishes this tool from siblings like commit_count (which publishes) and get_view (which just retrieves).

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 explicit when-to-use guidance: it tells the agent to call this for counting in the current view, warns not to add previous looks, and instructs to call commit_count after done. It also gives a conditional instruction for what to do if 'sufficient is false' (drive or ground). This is strong usage 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 burden and does substantial work: it discloses that the tool blocks until arrival/settling, that arrival detection relies on /state_estimation, that exactly one waypoint is published, and that coordinates are in map frame. It falls short only on timeout-expiration behavior and what happens if the vehicle never arrives.

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 sentences, all load-bearing: the action is front-loaded, the arrival-detection nuance is isolated in sentence two, and the ground() preference is in sentence three. Zero filler or repetition of schema information.

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

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

For a motion command with no annotations, the description covers the highest-risk ambiguities: coordinate frame, blocking behavior, arrival source, and where to obtain legitimate coordinates. Remaining gaps are timeout_s semantics and the no-arrival failure mode, but the existence of an output schema reduces the need to describe return values.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It adds the map-frame context for x and y, which is valuable, but says nothing about timeout_s beyond what the schema's default value implies. The most ambiguous parameter (timeout_s) is left undocumented.

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

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

States a specific verb-resource pair ('Publish one waypoint') plus the blocking behavior ('wait until the vehicle arrives or settles'). It also distinguishes itself by declaring that arrival is decided from /state_estimation, not a 'waypoint reached' topic, which separates it from sibling navigation 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?

Gives explicit input-sourcing guidance: 'Prefer publish_xy from ground() over coordinates you invent.' This clearly routes the agent to ground() for coordinate generation rather than fabricating values. However, it does not state when not to use drive_to or mention alternatives like stop for halting the vehicle.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It does describe the operation and output structure (splitting into four faces, returning pose), but it does not mention potential failure modes, prerequisites, or side effects. 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?

The description is three short sentences. The action is front-loaded, followed by usage guidance. Every sentence earns its place with no 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?

An output schema exists to document return values, and the description covers when to use the tool and what it captures. With no parameters, nothing else is needed for an agent to call it correctly.

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

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

The tool has zero parameters, and the schema coverage is 100% (vacuously). The description adds no parameter details because none are needed, which aligns with the baseline for 0-parameter tools.

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

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

The description clearly states a specific verb ('Capture'), a resource (the robot's 360° camera), and the output (four perspective faces and pose). It is distinct from sibling tools like drive_to or stop, but does not explicitly name any alternative or contrast with count_in_view.

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 explicitly tells the agent when to use it: 'Call this when you need to see the room' and 'Do not guess what is around you.' This gives clear context but does not name alternative tools or state when not to use it (e.g., for counting objects).

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

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

The description discloses the internal steps (pixel-grounding, lidar lift, size check, waypoint snapping) and the output flags (committed, visible) that guide subsequent actions. It does not explicitly state side effects, but implies it is a computation tool that returns coordinates.

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 compact but packed with necessary details: purpose, input format, process, and conditional usage. It is front-loaded with the core action and provides examples and next steps 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?

The description covers the input, process, and output usage including conditional logic based on committed and visible flags. It does not enumerate all error states, but the key behaviors are described. It leverages the output schema for detailed return structure.

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

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

The description explains the 'query' parameter with concrete guidance: pass the object or place in the instruction's own words, and even provides an example. This fully clarifies the meaning beyond the bare string type.

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

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

The description states a specific action (ground a referring expression) and the resource (live camera + lidar), and explains the process in detail. It distinguishes itself from siblings by focusing on pixel-grounding of references rather than counting or parsing.

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 explains how to use the output (publish_xy for drive_to) and provides conditional guidance based on committed and visible flags. It doesn't explicitly name alternatives or when not to use it, but the context is clear enough for an agent to know when to call 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 burden of disclosing behavioral traits. It conveys that the operation is a parse/split step and implies a read-only preparatory action, but it does not state whether there are side effects, external calls, or failure behavior for non-numerical questions. This is a moderate gap, not a severe one.

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

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

The description is two tight sentences with no filler. It front-loads the core behavior and then immediately gives usage context, making it easy to scan and act on.

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 parsing tool with an output schema available, the description covers the essential guidance: what it parses, what it produces, and how it fits into the larger workflow. It does not cover edge cases or input quality constraints, but those are minor given the tool's simplicity and the output schema's expected presence.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It does clarify that the 'question' parameter is a counting/numerical question and indicates the resulting parsed components. The parameter itself is self-explanatory, which further reduces the need for detailed parameter documentation.

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

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

The description states a specific action (split) on a specific resource (a counting/numerical question) and names the four output components: target, attribute, relation, and anchor. It clearly differentiates the tool's role from siblings like count_in_view by framing it as the preparatory parsing step.

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 explicitly says to use this tool first on numerical questions and explains that its output feeds into grounding and count_in_view. It gives clear sequencing and context, though it does not explicitly state when not to use it or name alternative conditions.

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

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

With no annotations provided, the description carries the full burden. It discloses that the box centre and size come from the lidar cluster rather than a guess, and that the operation depends on a prior grounding. However, it does not mention side effects (e.g., overwriting previous markers), error conditions, or whether the operation is reversible, leaving gaps.

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

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

The description is three sentences with no filler. It front-loads the purpose and places the critical prerequisite in the second sentence. Every sentence adds value, and the structure is clear and 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 has a single parameter that is unexplained, which is a major gap. Although the description covers the purpose, dependency, and data source, the unresolved 'label' parameter makes the tool incomplete for correct invocation. The presence of an output schema reduces the need to describe return values, but the parameter gap remains.

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

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

The sole parameter 'label' receives zero explanation in the description. Since schema description coverage is 0%, the description must compensate, but it never mentions what 'label' represents or how to fill it. This is a critical omission that leaves the agent guessing about expected input.

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 'publish' and the specific resource '/selected_object_marker', and ties it to the last grounded object. It also distinguishes itself from siblings by referencing ground() and the lidar cluster data, making the tool's scope 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?

It explicitly instructs to call ground() on the unique referred object first, which is a clear prerequisite. It gives context for when to use it (after grounding) but does not explicitly mention when not to use it or alternatives, though the prerequisite effectively implies it.

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

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

With no annotations, the description carries the burden of disclosing behavior. It states the immediate effect (park at current pose, stop chasing waypoint) and implies a safe stop action. It does not mention side effects (e.g., if called during motion), but for a zero-parameter stop command, the effect is sufficiently clear.

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

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

Two sentences, zero fluff. The first sentence states what it does; the second states when to use it. Information is front-loaded and 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?

For a tool with no parameters, the description fully explains its purpose and the exact situations to invoke it. No additional details (like return values) are needed since the tool is a state-changing command and there is no output schema complexity.

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

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

There are no parameters, so the baseline of 4 applies. The description does not need to explain any parameters, and the schema (empty object) is fully covered by the description's inference that no inputs are 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?

Clearly states the action (park at current pose) and the effect (local planner stops chasing last waypoint), distinguishing it as a termination command. The description is specific and unambiguous, easily differentiated from siblings like drive_to or publish_object.

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?

Explicitly instructs when to call: 'when the instruction is finished, or after you have published a numerical or object-reference answer.' Provides clear triggering conditions, though it does not explicitly list when not to use it. Alternative tools are not mentioned, but the context makes the timing obvious.

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