RoboSelect360 - Humanoid Robot Intelligence

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

The description adds significant behavioral context beyond the annotations: it explains the access-right requirement and the exact failure behavior ("if one is missing the call returns a refusal naming it, and compares nothing"). This is richer than the readOnlyHint and destructiveHint, which are already covered. There is no contradiction with annotations.

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

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

The description is two sentences, with both sentences providing essential information—purpose first, then requirement and failure. Every word adds value; no redundancy or filler.

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

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

For a tool with one parameter and no output schema, the description covers purpose, domain, requirements, and failure mode. It is fairly complete, though it could be slightly more explicit about the output format (e.g., what the comparison result looks like). However, given the simplicity and the presence of sibling tools, it strikes a good balance.

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 provides some meaning for the 'robot_ids' parameter by indicating it should contain IDs for 2 to 5 robots, but it does not specify the format (e.g., comma-separated string, JSON array). With 0% schema description coverage, the description partially compensates but leaves ambiguity about how to supply the IDs.

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 explicitly states the tool's function: "Compare 2 to 5 robots side by side on semiconductor BOM, metrics, risk and geographic exposure." It specifies the verb (compare), resource (robots), and a distinguishing scope (semiconductor), which differentiates it from sibling tools like mechanical_compare_robots and software_compare_robots.

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

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

The description clearly implies the domain of use via 'semiconductor' in the description, distinguishing it from mechanical and software compare tools. It also states a concrete prerequisite: "Requires an access right on EVERY robot listed." However, it does not explicitly tell the agent when not to use it or recommend an alternative for other domains, stopping short of being fully explicit.

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

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

Beyond the annotations that already mark this tool as read-only and idempotent, the description adds meaningful behavioral context: it requires an access right on the named robot, or on at least one robot when robot_id is omitted. This is useful disclosure about authorization behavior.

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 short sentences, front-loaded with the core action and scope. The authorization requirement in the second sentence is essential and 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?

Given the simple parameter schema and the presence of read-only/idempotent annotations, the description is mostly complete. It explains the object/scope, the authorization constraint, and why this is different from sibling layer tools. It falls short only in detail theory expectations or return-value format.

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

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

Schema description coverage is 0%, so the description must compensate. It partly does: 'one functional block' clarifies block_id, and 'on the robot named, or on at least one robot when none is' explains the robot_id default behavior. However, the description does not explain the accepted formats, constraints, or how robot_id is used if omitted.

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 ('Analyse') and identifies the resource ('one functional block of the semiconductor layer') plus the scope ('for a single robot at a time'). It clearly distinguishes itself from mechanical_get_block_analysis and software_get_block_analysis by naming the semiconductor layer.

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 clear context: the tool targets semiconductor-layer functional blocks and handles a single robot per call. It does not explicitly name alternative tools or state when not to use it, but the layer and scope make the intended use fairly clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the requirement for an access right on the robot, which is useful behavioral context not captured by annotations. It also indicates the analysis focuses on specific dependency aspects, but does not describe return format or pagination, which are not critical given the read-only nature.

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 concise sentences, first stating the purpose and second noting the access requirement. No fluff or unnecessary detail, 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 simple read-only analysis tool with one parameter and no output schema, the description covers purpose, basis, and key aspects. It also notes the access requirement. It does not mention output format or explicitly differentiate from sibling dependency tools, but it is sufficiently complete for the given 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?

Schema coverage is 0% for the single parameter robot_id. The description implies the robot_id must be a valid robot on which the user has access rights, but it does not add format, constraints, or examples. This compensates partially for the lack of schema description but not fully.

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 provides geopolitical and supply chain dependency analysis for a single robot based on its semiconductor BOM. It lists specific aspects (geographic concentration, single-source exposure, export control) and distinguishes from sibling tools that cover other subsystems or general robot info.

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

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

The description gives a clear context: when you need semiconductor dependency analysis for one robot. However, it does not explicitly mention alternatives or when not to use it, though the scope is evident from the title and description.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive, so the description does not need to cover side effects. It usefully discloses output scope: specs, pricing, viability score, and a boolean-like teardown existence, plus consistency of commercial fields across variants.

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, front-loaded with the primary output, and every sentence earns its place. The variant clarification is especially useful without adding bloat.

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

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

Given the low complexity, strong annotations, and lack of output schema, the description is complete enough: it identifies the exact resource, output categories, coverage layer, and relationship to sibling variants. An agent can confidently select and invoke this 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?

The schema has only one self-explanatory required parameter, robot_id, with 0% description coverage. The description adds only that the tool targets 'one robot,' which helps but does not fully compensate for missing parameter details such as source or format of robot_id.

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, concrete purpose: returning a commercial profile of one robot with specs, pricing, and viability score, plus whether a semiconductor teardown exists. It also distinguishes the three get_robot variants by mentioning that the commercial fields are identical and the layer flag is the only difference.

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 clear context: this tool is for the commercial profile plus semiconductor teardown existence, and the variant note explains that the three get_robot tools differ only by layer. It does not explicitly name sibling alternatives like mechanical_get_robot or software_get_robot, but the layer distinction provides enough guidance for tool 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable behavioral context about requiring an access right and returning a refusal naming the robot if unauthorized, which is not covered by annotations.

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

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

The description is two succinct sentences: the first states the core purpose, the second covers authorization. No fluff, no redundancy, and it is front-loaded with the key 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 simple read-only tool with two parameters and no output schema, the description covers the essential output content and authorization behavior. The only gap is the lack of explanation for the blocks_only parameter, which leaves some incompleteness, but overall it is adequate for the tool's simplicity.

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

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

With 0% schema description coverage, the description must explain parameters. It mentions the output content (functional blocks, components, suppliers) but does not clarify the role of robot_id (though fairly obvious) or blocks_only (unclear whether it filters to only blocks or something else). The description adds minimal value 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 explicitly identifies the tool as a semiconductor bill of materials for one robot, listing functional blocks, components, and suppliers. This clearly differentiates it from siblings like hardware_get_robot (generic info) and hardware_compare_robots (comparison), making the specific purpose unambiguous.

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

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

The description provides clear context on when to use the tool (to retrieve a BOM for a specific robot) and even notes the access-right requirement. However, it does not explicitly mention alternatives or when not to use it, though sibling names and the specificity of the BOM make the intended use obvious.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds the important requirement of an access right on the robot, which is a behavioral constraint not covered by annotations. It does not describe pagination or response format, but given annotation coverage, this is adequate.

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

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

Two sentences, front-loaded with the core purpose, no redundancy. Every word adds value, and it efficiently conveys the tool's scope and a key prerequisite.

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 three parameters, no output schema, and no parameter descriptions, the description does not provide enough guidance for correct invocation. It lacks details on layer and include_global, and the return structure is unspecified. The description is too sparse for the tool's 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?

Schema description coverage is 0%, so the description must compensate by explaining parameters. It does not mention robot_id, layer, or include_global at all. The description only says 'one robot', which vaguely hints at robot_id, but fails to explain the other two parameters, leaving them ambiguous.

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 function: it returns active supply chain signals affecting a specific robot's semiconductor BOM. It distinguishes itself from siblings like hardware_list_signals (which likely lists all signals) and hardware_get_robot (which gets robot details) by explicitly mentioning 'one robot' and the semiconductor BOM scope.

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

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

The description implies usage for a single robot with a semiconductor BOM, providing clear context that this is not a list-all tool. However, it does not explicitly name alternatives or state when-not-to-use, so it lacks the explicit exclusion guidance that would merit a 5.

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

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

Annotations already cover safety-related traits: read-only, idempotent, and non-destructive. The description adds useful behavioral context by specifying what the status contains: profiles loaded, semiconductor signal counts, and load errors. There is no contradiction with the annotations.

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

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

The description is compact and front-loaded. The first sentence states what the tool does, and the second sentence resolves the most likely cross-layer confusion. 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, read-only status tool, this description is largely complete: it defines the layer, the area of health, and the relevant details it reports. The only minor gap is that no output schema exists, so the exact return shape is not described, but the tool summary is likely sufficient for invocation.

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

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

The tool has zero parameters, so the schema is trivially complete. The description still adds semantic value by clarifying that the tool is scoped to the semiconductor layer and what aspect of that layer it reports.

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 that the tool reports the health of the SEMICONDUCTOR layer, including profiles loaded, semiconductor signal counts, and load errors. It also distinguishes itself from sibling tools by explicitly noting that there is one status tool per layer and that the three report different layers rather than the same server.

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 clear contextual guidance: this tool is the system-status tool for the semiconductor layer, not for other layers. It also prevents the obvious confusion that hardware/mechanical/software status tools might all report the same server. However, it does not explicitly discuss when to prefer this tool over more granular hardware tools like hardware_get_robot_hardware.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds useful behavioral context that all three list variants return the same catalogue, preventing redundant calls, which goes beyond the annotations.

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

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

Two sentences efficiently state the purpose and usage guidance without excess. Front-loaded with the core action and immediately differentiates from siblings.

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

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

Given 8 optional filter parameters and no output schema, the description fails to explain most parameters, their defaults, or the response format, leaving significant gaps for an agent to correctly invoke the tool with proper filters.

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

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

The schema has 0% description coverage for its 8 parameters. The description mentions only 'semiconductor tier and payload,' which maps to two parameters (tier, min_payload), but leaves the other six unexplained, insufficiently compensating for the lack of schema descriptions.

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

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

The description clearly states the tool lists the robot catalogue with filters, mentioning semiconductor tier and payload. It explicitly distinguishes this tool from the mechanical and software variants by noting the catalogue is the same and this one is for semiconductor tier filtering.

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 explicit guidance: 'call one, not three' and 'Pick this one to filter by semiconductor tier,' telling the agent exactly when to use this tool versus the sibling list variants.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds useful context about panel-wide scope and the access-right requirement, but it does not describe pagination, filtering behavior, or response shape. With strong annotations, 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 two sentences, front-loaded with the main purpose and immediately followed by the critical scope and authorization caveat. Every sentence earns its place, with no redundant or filler content.

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

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

With 9 optional parameters, no output schema, and 0% parameter coverage, the description must carry significant contextual weight. It establishes scope and access requirements but leaves the filter parameters and expected response format almost entirely unexplained, making it insufficient for an agent to invoke the tool correctly with meaningful filters.

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% across 9 parameters, and the description only generically says 'with filters.' It adds no meaning about layer, region, signal_type, min_severity, component_type, or other parameters. The burden falls entirely on the description, which fails to explain any parameter.

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

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

The description uses a specific verb and resource: 'List semiconductor supply chain, performance and operational signals across the panel, with filters.' It explicitly differentiates from per-robot signal tools by saying 'Panel-wide, not per robot,' which clearly distinguishes it from hardware_get_robot_signals and similar siblings.

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

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

The description clearly frames the tool as panel-wide and not per-robot, implying that per-robot signal retrieval should use a different tool. It also notes the access-right prerequisite. It does not explicitly name the alternative tool, but the context is clear enough for an agent to make an informed choice.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description remains consistent with these. It adds valuable behavioral context about authentication requirements ('Requires an access right on EVERY robot listed') and partial-failure semantics ('returns a refusal naming it, and compares nothing'), which goes beyond the structured fields.

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 tightly written sentences front-load the purpose and follow up with the most important usage constraint. Every clause earns its place with no fluff.

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 comparison tool with no output schema, the description covers purpose, scope bounds, and the critical access-control failure case. It does not describe the return shape, but given the simple read-only profile, the description is reasonably 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 only parameter, robot_ids, has 0% schema description coverage, and the description only implies arity ('2 to 5 robots') without specifying the string format or how IDs are delimited. The description only marginally compensates for the schema gap, so an agent would still have to guess whether IDs are comma-separated, JSON-encoded, etc.

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

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

Description uses the specific verb 'compare' with a clear resource and scope: 'Compare 2 to 5 robots side by side on mechanical BOM, specifications, risk and geographic exposure.' The 'mechanical' qualifier distinguishes this from hardware_compare_robots and software_compare_robots, and the arity constraint adds precision.

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 clear context on when to use it via the access-right prerequisite and failure mode ('Requires an access right on EVERY robot listed; if one is missing the call returns a refusal naming it, and compares nothing'). However, it never explicitly names an alternative tool or states when NOT to use this versus siblings, so usage guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds value by mentioning access rights and the single-robot constraint. It does not contradict annotations and provides additional behavioral context beyond the structured hints.

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 sentences, front-loaded with the core action and scope, and includes a critical access-right note. No wasted words; every clause contributes to understanding the tool's purpose and usage constraints.

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 read-only analysis tool with no output schema, the description adequately covers the main domain (mechanical blocks), scope (single robot), and access prerequisites. It misses details on parameter semantics but given the tool's simplicity and clear naming, it is reasonably complete. The block type enumeration adds useful context.

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

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

Schema description coverage is 0%, and the description does not elaborate on block_id or robot_id beyond their names. It mentions 'block' and 'robot' but does not explain what block_id represents, what format it expects, or how robot_id interacts with the default empty value. This leaves parameter semantics mostly to the schema, which is sparse.

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 analyzes one mechanical block, listing the block types (actuation, structure, energy, perception) and scopes it to a single robot at a time. It distinguishes from siblings via the 'mechanical' prefix and the specific block analysis intent, unlike hardware/software counterparts.

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 provides clear usage context: analysis of a single robot at a time and the need for an access right on the named robot or any robot when none is specified. However, it does not explicitly contrast with sibling tools (e.g., hardware_get_block_analysis) or state when not to use it, leaving some room for inference from the naming convention.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read. The description adds the requirement of an access right on the robot, and enumerates analysis dimensions (geographic concentration, critical raw materials, single-source exposure). No contradiction with annotations.

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

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

Two sentences, front-loaded with the core purpose, followed by a necessary access-right caveat. The list of analysis dimensions is compact but informative; no wasted words.

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

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

Given the simple one-parameter read-only tool with no output schema, the description covers the purpose, scope, and access requirement adequately. It doesn't mention return details, but none are needed due to no output schema and low 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?

The schema only provides robot_id with a title, and schema description coverage is 0%. The description compensates by indicating the analysis is for 'one robot' and that access rights are required on the requested robot, giving practical meaning to robot_id. However, it doesn't describe format or constraints beyond that, so it's adequate but not exhaustive.

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 performs geopolitical and supply chain dependency analysis on a robot's mechanical BOM, listing specific outputs (geographic concentration, critical raw materials, single-source exposure). This distinguishes it from sibling tools like hardware_get_dependency_profile or software_get_dependency_profile by emphasizing 'mechanical BOM' and from compare tools by specifying 'for one robot'.

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

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

The description implies usage for analyzing a single robot's supply chain risks based on mechanical components. It doesn't explicitly name alternatives or state when not to use it, but the 'mechanical BOM' qualifier provides clear context relative to sibling tools. The access-right requirement adds a practical prerequisite.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive, so the description does not need to restate these. It adds useful output coverage context (specs, pricing, viability, mechanical status), but no additional behavioral traits such as auth, pagination, or response format. No contradiction with annotations.

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

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

The description is two short sentences that earn their place. It front-loads the main return content and then clarifies the relationship among variants, with no redundancy or filler.

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

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

For a simple one-parameter read-only getter, the description gives sufficient high-level output details and a note about variant consistency. It could add error conditions or exact field examples, but the available schema plus annotations make it reasonably 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 has only one parameter, robot_id, with no schema description and no explanation in the tool description. The identifier is fairly self-evident, but for low schema coverage the description should compensate; it does not mention robot_id format, source, or expected values.

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

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

The description clearly states that the tool returns a commercial profile (specs, pricing, viability score) plus mechanical-profile status for one robot. It identifies the resource and scope, although it lacks an explicit verb like 'retrieves' or 'gets' and only implicitly differentiates this from the other get_robot variants.

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

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

The description implies this tool is the mechanical-layer get_robot variant and notes that commercial fields are identical across all three variants, which gives some usage context. However, it does not explicitly state when to choose this over sibling tools like mechanical_get_robot_mechanical, compare_robots, or signals tools.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context by specifying the access right requirement and the refusal behavior on failure, exceeding what annotations alone convey. There is no contradiction.

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 concise sentences with no filler. The first sentence directly states the tool's output, and the second adds a crucial access control note. Every word contributes value.

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 enumerates BOM components but omits any details about return format, pagination, or the semantics of blocks_only. Given the absence of an output schema and the low parameter coverage, the description is insufficiently complete for a tool that returns a multi-component BOM.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not. The 'blocks_only' parameter is not explained at all, and robot_id is only implicitly understood. The description lists BOM categories but ignores parameter meanings, leaving the agent guessing about how to invoke the tool correctly.

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 purpose: 'Mechanical bill of materials for one robot' and enumerates components (motors, reducers, screws, bearings, batteries, structure, wiring). This distinguishes it from sibling tools like mechanical_get_robot_signals or hardware_get_robot_hardware.

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 mentions a prerequisite: 'Requires an access right on the robot requested; without it the call returns a refusal naming that robot.' However, it does not explicitly compare to sibling tools or state when to use this tool vs. alternatives like hardware_get_robot_hardware. The guidance is implied by the tool's name and category but not made explicit.

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

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

Annotations already cover readOnly, idempotent, and non-destructive traits. The description adds context about 'active' signals and the access right requirement, but does not elaborate on behavior like empty results, pagination, or error conditions. This adds some value beyond annotations but is minimal.

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

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

The description is a single, concise sentence that front-loads the core purpose before adding the access requirement. Every word contributes, and there is 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?

For a simple read-only tool with no output schema, the description covers the essential purpose and an access constraint. However, it leaves include_global unexplained and does not describe the return structure, making it only minimally adequate.

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

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

Schema description coverage is 0%, and the description does not mention include_global at all. It implicitly references robot_id via 'one robot' but lacks explicit parameter explanations, especially for include_global which is not self-evident.

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 what the tool returns: active supply chain signals affecting one robot's mechanical BOM. The scope is specific ('one robot', 'mechanical BOM'), distinguishing it from sibling tools like hardware_get_robot_signals or software_get_robot_signals.

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 (e.g., mechanical_list_signals or mechanical_get_robot). It mentions an access right requirement, but not the appropriate use case or exclusions.

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

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

The description states the tool is a read-only health check ('Health of the MECHANICAL layer'), consistent with readOnlyHint=true and destructiveHint=false. It adds context about having no parameters and implies a lightweight status check. However, it doesn't detail success/failure behaviors (e.g., what happens if layer is down), though the presence of annotations reduces the need for the description to restate safety.

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 sentences, front-loads the purpose, and wastes no words. The only minor flaw is the redundant clarification about per-layer reporting, which, while useful for disambiguation, could have been condensed without losing meaning.

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

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

For a zero-parameter, read-only status tool, the description is complete: it names the layer, hints at response fields, and clarifies scope (per-layer, not per-server). The sibling tools and annotations fill in the rest. A slightly more complete description might mention the output format (e.g., JSON structure), but given the tool's simplicity, this is nearly complete.

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

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

With zero parameters and 100% schema coverage (the schema is essentially empty), the description has no parameters to explain. It correctly focuses on what the tool returns and its purpose, which is exactly what an agent needs. The description's mention of 'load errors' and 'signal counts' hints at the response structure without needing a formal 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 clearly states what the tool does: reports health of the MECHANICAL layer (profiles loaded, signal counts, errors). It differentiates from siblings by explicitly noting this is one per layer and distinguishes from the 'same server' interpretation. However, it does not name any sibling tool (like mechanical_get_robot) for direct comparison.

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

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

The description implies this is the mechanical layer's equivalent of hardware/software status tools, but it doesn't explicitly say 'use this when you need mechanical layer health' or specify when NOT to use it. The 'one status tool per layer' comment gives context but no explicit alternative naming.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds value by noting the catalogue is identical to the hardware and software variants, and highlights mechanical filtering capabilities. This is useful context beyond the annotations, though it doesn't describe output format or pagination.

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 concise sentences that front-load the purpose and then give usage guidance. Every word earns its place; no redundancy or fluff.

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 8 parameters, no output schema, and no parameter descriptions, the description provides only a high-level overview. It mentions mechanical status and payload as filters but omits details on other filters like country, category, or scope. While it clarifies the catalogue is shared across variants, it lacks enough to fully guide an agent on input configuration or expected output.

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% with 8 parameters. The description only hints at 'mechanical-profile status and payload' but does not explain any of the parameters (e.g., pays, categorie, in_scope_only, limit, offset). Since the schema lacks descriptions, the description should compensate, but it only partially does, leaving most parameters 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?

The description clearly states the tool lists the robot catalogue with filters, specifically mentioning mechanical-profile status and payload. It distinguishes from hardware and software variants by explicitly naming them and stating this one is for mechanical coverage, which differentiates it from siblings like hardware_list_robots and software_list_robots.

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 says 'call one, not three' and 'Pick this one to filter on mechanical coverage,' providing clear when-to-use guidance and alternative identification. This directly addresses selection among the three list variants.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. Description adds the scope constraint (panel-wide vs per-robot) and the access-right requirement, which are not in annotations. This provides useful context for invocation without redundancy.

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 concise sentences, front-loaded with the action and resource. No filler words; both sentences provide 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 read-only listing tool with annotations covering safety, the description covers purpose, scope, and access requirements. However, it lacks any parameter semantics and does not describe pagination or return structure, which is significant given no output schema. It's adequate but has clear gaps.

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

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

Schema description coverage is 0% and the description does not explain any of the 8 parameters. It only says 'with filters' generically, leaving the meanings of signal_type, min_severity, component_type, etc. unexplained. The description fails to compensate for the lack of schema descriptions.

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

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

Description uses specific verb 'List' with clear resource 'mechanical supply chain, performance and operational signals' and scope 'across the panel'. It distinguishes from per-robot siblings by stating 'not per robot', clarifying this is the panel-wide signal listing tool.

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 states 'Panel-wide, not per robot', providing a clear when-not guideline. Also discloses access prerequisite ('requires an access right on at least one robot'). While it doesn't name sibling alternatives, the domain qualifier 'mechanical' and contrast with per-robot tools sufficiently guides 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?

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the bar is lower. The description goes beyond this by disclosing a specific access-control requirement (access right on EVERY robot) and an important failure mode: returns a refusal naming the missing-robot and compares nothing. This is genuinely valuable operational 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 two succinct sentences with no filler. It front-loads the core purpose and comparison topics, then adds the access-control caveat. Every sentence contributes information not already in the structured fields.

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 one simple parameter, clear annotations, and no output schema, the description is reasonably complete. It explains the scope, supported cardinality, access prerequisites, and failure behavior. The only notable gap is the lack of robot_ids serialization format, which prevents a perfect score given the absence of parameter-level schema details.

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 describes only 'robot_ids' as a string with no description. The description adds semantic meaning by indicating that the parameter must encode 2 to 5 robots and that access rights are checked per robot, but it does not clarify the expected string format (e.g., comma-separated IDs, JSON array, repeated delimiters). This partial compensation justifies a middle score.

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

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

The description clearly states a specific action ('Compare 2 to 5 robots side by side') and specifies the exact comparison dimensions (software BOM, TCO, jurisdiction exposure, lock-in, export control risk). It is also easily distinguished from sibling tools like hardware_compare_robots and mechanical_compare_robots because it explicitly mentions 'software' and those dimensions.

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 clear context for use: comparing a bounded set of robots on software-related criteria. It also states an explicit precondition (access right on every robot) and describes failure behavior. It does not explicitly name alternatives, but the sibling tool names and the 'software' qualifier make the intended use vs hardware/mechanical variants clear.

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

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

Annotations already identify the tool as read-only, idempotent, and non-destructive, so the description does not need to repeat those. The description adds useful auth/access context and a single-robot constraint, but it does not disclose behavior for invalid/missing robot authorization or how an omitted robot_id is resolved when multiple robots are accessible.

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 and front-loaded: a clear verb, a scope-defining object, a single-robot constraint, and an access prerequisite. It contains no filler or redundant restatements of the tool name.

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

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

The description is adequate for a simple permission-gated read tool, but no output schema exists, so 'analyse' is left vague: it does not say what the result contains or how the block analysis differs from related tools like dependency-profile or system-status. More detail about return value and block_id semantics would significantly improve 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 0% schema-description coverage, the parenthetical block types provide meaningful interpretation for block_id, and the access condition clarifies robot_id's optional role. However, it still lacks exact valid values for block_id and clear behavior for omitted robot_id when there are multiple accessible robots.

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 'Analyse' and clearly names the resource: one software block (OS, middleware, runtime, control, fleet) for a single robot. It distinguishes itself from the hardware/mechanical block-analysis siblings and from other software_* tools such as software_get_robot or software_compare_robots.

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 states the scope clearly: analyze one software block, one robot at a time, and it gives an access-right prerequisite. It does not explicitly name alternative tools or state when not to use this tool, so it falls short of fully explicit when/when-not guidance.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds a valuable operational requirement: 'Requires an access right on the robot requested.' This surfaces a prerequisite that could affect invocation, going beyond what annotations state. No contradictions with annotations.

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

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

The description is two sentences, concise and front-loaded with the primary purpose. It details the specific analyses performed and the access requirement without any fluff or redundant information. Every sentence adds value.

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

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

Given the tool has no output schema, the description lists the analysis dimensions (jurisdiction concentration, lock-in, export control, cloud dependency), giving a clear idea of what the result might contain. It does not describe the output format or error conditions, but for a single-input get operation, the provided context is reasonably 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 only parameter is 'robot_id' which is self-explanatory from its name and schema, but the description does not elaborate on it. The phrase 'for one robot' implies the parameter identifies the target, but no additional meaning or constraints are provided. Schema coverage is 0% since the description never references the parameter directly.

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 performs 'Jurisdiction and supply chain dependency analysis for one robot, built on its software stack' and lists specific analysis types (jurisdiction concentration, lock-in, export control, cloud dependency). This distinguishes it from sibling tools that focus on hardware or mechanical aspects, making the purpose unambiguous.

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

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

The description does not provide explicit guidance on when to choose this tool over alternatives. While it mentions 'for one robot', it does not contrast with other get_* tools (e.g., hardware_get_dependency_profile) or list conditions for use. The reader must infer when this analysis is appropriate based on the software stack focus.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds useful context about cross-variant consistency (commercial fields identical, layer flag is the only difference) and enumerates the returned profile components, which goes beyond the annotations without contradicting them.

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

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

Two concise sentences with no filler. The first sentence front-loads the core purpose and return fields, and the second adds a valuable cross-variant clarification.

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, read-only tool with no output schema, the description adequately covers purpose, key return fields, and the relationship to sibling variants. It lacks explicit return structure or status value details, but it is sufficient for selection and basic invocation.

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

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

The schema has only robot_id with no description, and schema description coverage is 0%. The description does not explain the format, origin, or expected values of robot_id, so it fails to compensate for the lack of 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 clearly states the tool returns a commercial profile for one robot (specs, pricing, viability score) plus software tier and profile status. It also distinguishes itself from the hardware and mechanical get_robot variants by noting the commercial fields are identical and only the layer differs.

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

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

The description implies this variant is for software-layer coverage and clarifies that the three get_robot variants share commercial fields. However, it does not explicitly state when to prefer this over software_get_robot_software or list tools, so exclusions are not fully articulated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context beyond annotations by noting that only 'active' and 'affecting' signals are returned and that an access right is required, which is not captured in the annotations. No contradiction exists.

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 sentences, each earning its place: the first states the core purpose and scope, the second states a prerequisite. It is front-loaded and free of 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?

With no output schema and only two parameters, the description covers the basic purpose and a prerequisite, ensuring minimal viability. However, it omits the semantics of 'include_global' and leaves the term 'active' ambiguous (e.g., time window or status), so the agent may not fully understand the response scope. It is adequate but incomplete for a tool with a low-coverage schema.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. 'robot_id' can be inferred from 'one robot', but 'include_global' is entirely unexplained, leaving the agent unsure whether global supply chain signals are included by default or how the flag modifies results. The description fails to compensate for the missing schema descriptions.

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

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

The description clearly identifies the resource ('active supply chain signals') and the scope ('one robot's software stack'), which differentiates it from hardware/mechanical variants. However, it lacks an explicit verb (e.g., 'get' or 'list'); the verb is only present in the tool name, so the description alone doesn't fully state the action.

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 a prerequisite ('Requires an access right on the robot requested'), which is a useful usage condition. It does not explicitly mention when to use this tool instead of siblings like hardware_get_robot_signals or software_list_signals, though the 'software stack' and 'one robot' wording imply the appropriate context.

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

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

Annotations already declare the operation safe/read-only/idempotent. The description adds useful behavioral context beyond annotations: the caller needs an access right on the specific robot, and unauthorized calls return a refusal naming that robot.

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

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

Two sentences: the first front-loads the core purpose and contents, the second adds a critical access/error condition. 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?

The description covers the BOM contents and auth behavior, but with no output schema and an undefined blocks_only parameter, there are notable gaps. It is minimally viable but not fully complete.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only loosely implies robot_id via 'one robot' and says nothing about blocks_only, leaving the boolean parameter's semantics unclear.

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 tool as a software bill of materials scoped to one robot and enumerates the component layers (OS, middleware, AI runtime, motion control, fleet management). This clearly differentiates it from list/compare/get-robot siblings.

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

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

The tool's scope is explicitly limited to one robot, and the access-right requirement plus refusal behavior gives a clear precondition. It does not explicitly name alternatives, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds value by specifying the exact health metrics included (profiles loaded, signal counts, load errors). With annotations handling safety, this provides meaningful 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?

Two efficient sentences: the first states the purpose and content, the second clarifies sibling differentiation. No fluff, every word adds value.

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

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

For a parameterless, read-only status tool with strong annotations, the description is complete. It describes what the tool reports, distinguishes it from siblings, and the lack of output schema is acceptable since the description gives a high-level idea of the returned data.

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 per the rubric the baseline is 4. The description correctly avoids addressing parameters since there are none, and the schema is already complete with no properties.

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 that this tool reports health of the SOFTWARE layer, listing specific metrics (software profiles loaded, signal counts, load errors). It also explicitly distinguishes itself from sibling status tools by noting that each layer has its own status tool reporting different layers, not the same server.

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

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

The description implies usage: use this for software-layer health status. It provides context that hardware and mechanical layers have their own status tools, effectively differentiating when to use this vs siblings. However, it does not explicitly state when NOT to use it or alternative tools by name.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds that this returns the same catalogue as hardware and mechanical variants, and highlights inclusion of software tier and software-profile status. This gives useful behavioral context about output equivalence and filter scope, though it doesn't detail pagination or error behavior.

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 succinct sentences with no filler. Each sentence adds value: what it does, the equivalence to other variants, and selection guidance.

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 gives a solid overview but lacks detail on most filters and return values. Given 8 parameters and no output schema, more explanation of parameter semantics would be needed for full completeness, though annotations and the simple list nature keep it minimally viable.

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

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

Schema description coverage is 0%, so the description must compensate. It only explicitly mentions the software_tier filter, leaving seven other parameters (pays, limit, offset, status, categorie, min_score, in_scope_only) unexplained. This is a significant gap for a list tool with 8 optional filters.

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 lists the robot catalogue with filters, specifically mentioning software tier and software-profile status. It distinguishes from sibling hardware/mechanical list_robots variants by noting this is the software-filtered version and that the catalogues are identical.

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?

Explicit guidance says 'Pick this one to filter by software tier' and warns 'call one, not three', directly telling when to use this tool versus the hardware and mechanical variants. This provides clear context and exclusions.

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

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

Annotations already declare this as a read-only, idempotent, non-destructive operation. The description adds the access-right requirement and the panel-wide scope, which are behavioral constraints not covered by annotations. No contradictions.

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 highly concise, with two short sentences providing the essential purpose, scope, and prerequisite. No redundant 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?

The description is adequate for a list tool but lacks details on the filter parameters and the response format. With no output schema and only vague filter references, the agent may need additional context to fully utilize the tool, especially given the number of parameters.

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%, yet the description does not explain any of the 9 optional parameters. It merely says 'with filters' without defining what each filter (e.g., domain, block_id, signal_type, min_severity) does. The agent is left to guess parameter meanings from names alone.

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

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

The description clearly states the tool lists software supply chain signals panel-wide, with filters. It explicitly differentiates from per-robot tools by saying 'Panel-wide, not per robot,' distinguishing it from sibling tools like software_get_robot_signals and hardware_list_signals.

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 clear usage context: it is for panel-wide signal listing, not per-robot, and requires an access right on at least one robot. It implies the alternative of using per-robot tools but does not explicitly name them.

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