RoboSelect360 - Independent Humanoid Robot Intelligence

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely new behavioral facts the annotations cannot express: it is free, requires no API key, and needs no account — real auth and cost constraints. It does not describe result shape beyond the field list, which keeps it at 4.

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 'what you can call right now' framing and closing with the actionable 'call it FIRST' directive. The first sentence is a dense four-item enumeration that reads as a run-on, but every clause carries distinct information.

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

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

With no output schema, the description carries the burden of explaining return content, and it does so by listing the four manifest categories. Combined with the no-auth, no-cost disclosure, an agent has enough to call it and interpret results; only the shape of the returned data (per-tool entries vs. lists) is left unspecified.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter surface for the description to clarify or omit.

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

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

The description names a specific resource (this connection's access manifest) and enumerates exactly what it contains: free-to-call tools, right-gated tools, owned robots, unlockable robots. That is far more informative than the title. It stops short of naming or contrasting any sibling tool, so an agent must infer that no hardware_*/software_* tool overlaps.

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

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

It gives an explicit sequencing directive ('Call it FIRST') with the rationale that it avoids trial calls that will be refused, which implicitly steers the agent away from probing gated tools. There is no stated case for when not to call it or an explicit alternative, so it falls short of full 5-level 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 cover read-only, idempotent, non-destructive, closed-world. The description adds genuinely non-obvious behavior: the access-right requirement and the fact that a refusal is returned naming the robot, plus that failures are included in the evidence and each observation carries source, conditions and control mode. It stops short of describing result ordering, volume limits, or what an empty evidence set looks like beyond the 'no evidence found' label.

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, then the evidence taxonomy and finally the refusal case. The enumerated label list earns its space because it tells the agent how to interpret results.

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

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

With no output schema, the description usefully describes the return shape (label per capability plus dated observations with source, conditions, control mode) and the error case. The main remaining gap is robot_id format, which matters for correct 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?

Only one parameter (robot_id) with 0% schema description coverage, so the description must carry the burden. It implies the parameter identifies the robot to check and governs the access-right check ('naming that robot'), but never states the expected format (ID vs name) or what happens when the ID is unknown — partial compensation only.

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 opens with a specific resource and scope: 'What one robot has actually been seen doing, and the evidence for each capability,' which is far more informative than the title 'Observed capabilities.' It never names a sibling (e.g., hardware_get_robot_signals or get_robot_support) to differentiate itself, so an agent must infer the boundary from the resource alone.

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

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

Usage is implied by the resource — call this when you need evidence of what a robot has actually done — and a precondition is stated ('Requires an access right on the robot requested'). However, there is no explicit when-to-use-versus-alternative guidance against the many sibling capability/signal 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 declare readOnly/idempotent/non-destructive, so the description doesn't need to restate safety, and it doesn't. Instead it adds real behavior beyond the annotations: an access right is required and the failure mode is a refusal naming the specific robot, plus every fact is returned with who asserts it, an evidence level, a verbatim quote and source, with unknowns explicitly labeled and dated. It stops short of covering pagination or response envelope shape, so a 4 rather than 5.

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?

Purpose and audience are front-loaded in the first clause, and the long enumeration is dense rather than padded — each listed item is a real returned field. It is a single run-on sentence, which makes the provenance and access-requirement facts slightly harder to extract than they should be.

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

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

With no output schema, the description has to describe the payload, and it does so field by field including provenance metadata and the treatment of unknowns. Combined with the annotations and the disclosed access-refusal behavior, an agent knows what it will get and what can go wrong; only the id format and response envelope are left unspecified.

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

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

Schema description coverage is 0% for the single parameter, and the description never explains robot_id beyond 'of one robot' and 'an access right on the robot requested' — no format, no origin, no hint that access is scoped per robot id. With only one parameter the baseline is high, but the description does little to compensate for the bare 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 names a specific resource (the after-sales support profile of one robot) and enumerates its exact contents — warranty duration and exclusions, dated spare-part offers, maintenance obligations, software subscriptions, EU service, lifecycle, and open diligence questions. That scope is clearly distinct from the hardware/mechanical/software/capabilities sibling profiles, so an agent can route correctly without opening either schema.

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

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

Usage is only implied: 'for a buyer in Europe' and 'the open questions to ask before signing' signal a pre-purchase diligence scenario, and the access requirement is stated. But there is no explicit when-to-use/when-not, and no sibling is named as the alternative (e.g. versus software_get_robot_software for update history).

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 the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds a genuinely non-obvious trait: the operation is all-or-nothing on authorization — one missing right causes a refusal naming the robot and no comparison at all. That failure mode is not derivable from the schema or annotations. It could go further by describing the shape or size of the returned comparison, but the key behavioral risk is disclosed.

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

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

Two sentences, zero filler, with the scope and the authorization precondition front-loaded. Every clause carries information an agent needs before calling.

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 comparison with no output schema, the description covers what is compared and how failure behaves, which is close to sufficient. The remaining gap is the multi-ID string encoding and any hint about the comparison result's structure or size.

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

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

Schema coverage is 0% and robot_ids is an untyped-description string, so the description carries the burden. It usefully constrains the count to 2-5, which the schema does not enforce, but never explains how multiple IDs are encoded in a single string (delimiter, array serialization, ordering). The cardinality hint partially compensates for the coverage gap but leaves the actual encoding 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?

States a specific verb (compare), resource (robots), cardinality (2 to 5), and the exact comparison dimensions (BOM, metrics, risk, geographic exposure). The word 'semiconductor' in the body and title cleanly separates it from the mechanical_compare_robots and software_compare_robots 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?

Gives the operating envelope — 2 to 5 robots and an access right required on every listed robot — which tells the agent when the call is valid. It stops short of routing guidance (e.g., use hardware_get_robot for a single robot, or list_robots to discover IDs), so alternatives are implied rather than named.

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/non-destructive, so the safety profile is covered. The description adds genuinely new behavioral context: the access-right requirement on the named robot, or on any robot when none is given, which is not derivable from the schema or 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 tight sentences with the block scope front-loaded and no filler. It is appropriately sized, though brevity here partly reflects under-specification rather than disciplined trimming.

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 0% schema coverage and no output schema, the description needs to explain both the block_id input and what the analysis returns. Neither is addressed, leaving the agent without enough to invoke it confidently beyond the permission note.

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 carries the full burden. It hints that robot_id is optional ('when none is'), but says nothing about what block_id is, its format, or where to obtain a valid value.

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 (analyse) and resource (one functional block) and scopes it to the semiconductor layer, which separates it from mechanical_get_block_analysis and software_get_block_analysis. It does not say what an 'analysis' actually produces, so the purpose is clear in domain terms but not in output terms.

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?

Implies usage through scope ('one functional block of the semiconductor layer') and adds a real constraint ('a single robot at a time'), but never names the mechanical/software sibling variants or states when one should be preferred over them. Adequate but leaves alternative-selection to inference.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds a genuinely useful authorization constraint ('Requires an access right on the robot requested') that the annotations do not express, which is exactly the kind of context that prevents a failed call. It does not mention failure behavior when the access right is missing, so it falls short of a 5.

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, no filler, and the core purpose with its analysis dimensions is front-loaded before the access caveat. Every clause 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 single-parameter read tool with no output schema, the description covers what the analysis produces (three named dimensions), the data basis (semiconductor BOM), and the access prerequisite. The remaining gap is sibling disambiguation, which matters a lot here because three near-identically named dependency profile tools exist across domains.

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% on the single robot_id parameter, so the schema contributes no semantics. The description partially compensates: 'for one robot' establishes that robot_id scopes the analysis to a single robot rather than a fleet, and the access-right sentence implies the id is validated against permissions. It still says nothing about the identifier's format or where to obtain it.

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

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

The description states a specific verb-plus-resource ('dependency analysis for one robot, built on its semiconductor BOM') and enumerates the analysis dimensions (geographic concentration, single-source exposure, export control), so the purpose is unambiguous. It does not, however, distinguish itself from the sibling tools mechanical_get_dependency_profile and software_get_dependency_profile, which appear to be the same analysis over a different BOM domain.

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

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

Usage is implied by the domain wording ('semiconductor BOM'), so an agent can infer this is the hardware-domain dependency profile. But it never states when to pick this over the mechanical or software dependency profiles, nor any prerequisites beyond the passing mention of an access right. Minimum viable rather than directive.

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 full safety profile (readOnly, idempotent, non-destructive, closed-world), so the description doesn't need to. It adds useful contract detail about what the payload contains and that BOM existence is a yes/no indicator rather than a full BOM. It omits error behavior for an invalid robot_id and gives no sense of payload size.

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 tight sentences, content front-loaded, no filler. The only weak spot is the trailing 'layer flag' clause, which introduces ambiguity rather than 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?

With no output schema, the description carries the burden of explaining return content, which it does at a high level (specs, pricing, viability score, BOM-existence flag). Still missing are the identifier's provenance and failure behavior, both relevant for a single-required-param lookup tool.

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

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

Schema description coverage is 0% for the single parameter robot_id, so the description must compensate and it does not — robot_id is never mentioned, nor its format or how to obtain one (e.g., from hardware_list_robots). This is a meaningful gap for a tool whose only input is an identifier.

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?

Names a specific resource (one robot's commercial profile) and enumerates its contents: specs, pricing, viability score, plus semiconductor BOM existence. It also positions itself against the other two get_robot variants. The closing phrase 'the layer flag is the only difference' is slightly muddy since no layer parameter exists in the schema, but the intent is still readable.

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?

Implies the tool is the hardware-layer counterpart of mechanical_get_robot/software_get_robot and that the commercial payload is identical across them, which is useful routing context. However, it never states when to prefer this over hardware_get_robot_hardware, get_robot_capabilities, or get_robot_support, nor any exclusion 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?

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower; the description still adds real value by disclosing the authorization requirement and the exact failure behavior (a refusal naming the robot). It does not describe the response shape or whether suppliers are always populated.

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 tight sentences: content first, prerequisite and failure mode second. No filler, and the key scoping information is front-loaded.

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

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

With no output schema, the description should convey more about what comes back, and the undocumented blocks_only flag leaves an agent guessing whether the result is a full BOM or a blocks-only view. Auth and read-only semantics are adequately covered.

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

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

Schema description coverage is 0% for two parameters. The description never mentions robot_id or, more importantly, blocks_only — a filtering flag whose effect is only vaguely hinted at by the phrase 'functional blocks, components, suppliers'. The most consequential parameter is left entirely unexplained.

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 resource and enumerates its content: 'Semiconductor bill of materials for one robot: functional blocks, components, suppliers.' The 'Semiconductor' qualifier implicitly separates it from the mechanical_/software_ counterparts in the sibling list, but no sibling is named explicitly.

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

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

The description implies usage (fetch the BOM for one robot) and states a prerequisite access right, but never says when to prefer this over hardware_get_block_analysis or hardware_get_dependency_profile, which clearly overlap with the 'functional blocks' content it advertises.

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, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds the permission requirement, which is genuinely useful, but says nothing about what 'active' means, how signals are filtered, or the result shape.

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

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

Two short sentences, front-loaded with the core purpose and followed by the access prerequisite. No waste, though the brevity is partly under-specification rather than efficiency.

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 0% schema coverage, the description must carry the definitional burden for layer and include_global, and it does not. For a per-robot analysis tool with an ambiguous 'layer' input, an agent is left guessing at invocation 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?

Schema description coverage is 0% across three parameters. The description only implies robot_id ('one robot'); the 'layer' parameter is completely unexplained and 'include_global' defaults are undocumented, so an agent cannot know how these change the result.

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 resource and scope: active supply chain signals affecting one robot's semiconductor BOM. The word 'signals' plus 'semiconductor BOM' and 'one robot' distinguishes it from hardware_list_signals (all robots) and from mechanical_/software_ variants, though it never names those alternatives explicitly.

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

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

'Affecting one robot' implies per-robot usage and 'Requires an access right on the robot requested' adds a real prerequisite. But there is no explicit guidance on when to pick this over hardware_list_signals or the mechanical/software signal tools, leaving routing to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds what the status actually surfaces (loaded profiles, signal counts, load errors), which is useful behavioral context absent from the annotation set.

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 filler, with the layer scope and the contents of the report front-loaded before the disambiguation note. Every clause 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 with no output schema, the description covers what is reported and how it differs from siblings. It stops short of describing the response shape or error behavior, a minor gap given 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?

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate beyond scope, which it does by naming the layer.

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 resource (the SEMICONDUCTOR layer) and enumerates the concrete outputs: profiles loaded, semiconductor signal counts, load errors. It also explicitly distinguishes itself from the mechanical_ and software_ status siblings by noting each reports a different layer 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 line 'One status tool per layer - the three report different layers, not the same server' directly tells an agent when to pick this tool over the sibling status tools. It doesn't cover when to prefer signal-level tools like hardware_get_robot_signals, but the primary ambiguity is resolved.

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, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely useful behavior beyond that: the three list variants return identical catalogues, so calling more than one is redundant. It says nothing about pagination, default result size, or sort order despite having limit/offset and a score field.

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

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

Three tight sentences, front-loaded with the action, followed by the de-duplication rule and the selection criterion. No filler and no repetition of the title or annotations.

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 sibling-disambiguation problem, the hardest part of this tool family, is fully solved, and there is no output schema to explain. However, an eight-parameter unannotated-in-schema list tool should at least describe pagination defaults and what the remaining filters accept; an agent can pick the tool but will likely guess at parameter usage.

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

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

Schema description coverage is 0% – all eight parameters carry only titles and defaults, with no explanation of format. The description adds meaning only for the scope-related filter and payload ("semiconductor-layer scope and payload"), leaving pays, categorie, min_score, limit, offset and the in_scope_only=true default entirely unexplained. With zero coverage the description needed to carry far more of this burden.

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

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

States a specific verb and resource ("List the robot catalogue with filters") and immediately scopes it to semiconductor-layer and payload filtering. It explicitly distinguishes itself from the near-identical siblings mechanical_list_robots and software_list_robots, which is the key disambiguation an agent needs here.

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?

"Returns the same catalogue as the mechanical and software variants - call one, not three" plus "Pick this one to filter on whether a robot is in scope for the semiconductor layer" gives an explicit selection rule against the three parallel list tools. It gives no guidance relative to the other hardware_* siblings such as hardware_get_robot or hardware_compare_robots, so the routing is strong but not exhaustive.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds a genuine operational constraint ("requires an access right on at least one robot"), but says nothing about pagination behavior, default filtering behavior, or what the feed returns.

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

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

Two short sentences with the scope statement front-loaded and zero filler. Every phrase carries 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 9-parameter, zero-coverage tool with no output schema, the description is too thin: an agent cannot know filter semantics, sort order, default result size, or result shape. The one thing it does add beyond structured fields is the access prerequisite.

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?

Nine parameters with 0% schema description coverage leaves the entire parameter surface undocumented except for a generic "with filters". Nothing explains what layer, region, block_id, signal_type, min_severity, component_type, or active_only mean or what values they accept, so the description fails to compensate for the schema gap.

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

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

States a specific verb and resource ("List semiconductor supply chain, performance and operational signals") and scopes it as panel-wide rather than per-robot, which separates it from hardware_get_robot_signals and the mechanical/software siblings. It stops short of explicitly naming those alternatives, but the domain and scope are 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?

"Panel-wide, not per robot" implies when to reach for this tool instead of a per-robot signal getter, and the access precondition is stated. However, no sibling is named and nothing tells the agent when to prefer, say, hardware_get_robot_signals or mechanical_list_signals over this one, so routing is left partly to inference.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new behavioral facts: an access right is required on EVERY listed robot, and a single missing right produces a refusal naming that robot with nothing compared — an all-or-nothing failure mode an agent must know before calling.

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 waste. The scope and comparison dimensions come first, and the precondition/failure clause follows — exactly the right ordering for a pre-call decision.

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 comparison tool with a one-parameter schema and no output schema, the description covers what is compared and the blocking failure mode well. The only real gap is the ID list encoding, which matters because it is the sole required input.

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

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

Schema coverage is 0% and the single parameter is an undescribed string, so the description must compensate. It does supply the critical 2-to-5 cardinality bound, but never explains how multiple robot IDs are encoded in that string (comma-separated, repeated, etc.), leaving the main practical ambiguity unresolved.

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 (compare), resource (robots), and the exact dimensions compared (mechanical BOM, specifications, risk, geographic exposure). The 'mechanical' qualifier cleanly separates it from hardware_compare_robots and software_compare_robots in the sibling set.

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 2-to-5 cardinality constraint is stated, which shapes how the tool should be called, and the mechanical framing implies the domain relative to its hardware/software siblings. However, it never explicitly says when to choose this over hardware_compare_robots or software_compare_robots, nor does it name any alternative.

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 the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuinely new behavioral context: an authorization requirement keyed to the robot, including the fallback rule when no robot is given. It does not describe what the analysis returns or how failures surface.

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 filler; the scope constraint is front-loaded and the prerequisite follows. Every clause carries information an agent needs before calling.

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 call with no output schema, the description covers purpose, scope and auth but leaves the return payload and id formats unexplained. Adequate to attempt a call with the obvious required block_id, less so to invoke it correctly with an optional robot_id.

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

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

Schema coverage is 0%, so the description must carry parameter meaning, and it only partially does: block_id is implied to be one of actuation/structure/energy/perception, and robot_id is implied optional by 'when none is'. It never states accepted id formats, whether block_id is an enum, or that robot_id defaults to an empty string.

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 ('Analyse') plus resource ('one mechanical block') and enumerates the four block categories covered. The 'mechanical' prefix and 'single robot at a time' scope let an agent distinguish it from the hardware_ and software_ block-analysis siblings without opening a schema.

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

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

Gives a clear usage context via the 'single robot at a time' constraint and an explicit prerequisite ('Requires an access right on the robot named, or on at least one robot when none is'). It stops short of naming alternatives such as software_get_block_analysis for non-mechanical blocks, so the agent must infer domain routing from the 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?

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), so the description's added value is the permission requirement ('Requires an access right on the robot requested') and the enumeration of what the analysis actually covers. That is real context beyond structured fields, though it doesn't say what happens when access is missing.

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 tight sentences: the analytical scope comes first, the access prerequisite second. No filler and nothing an agent must read past to find the core purpose.

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

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

There is no output schema, and the description compensates by naming the analysis dimensions returned (geographic concentration, critical raw materials, single-source exposure). Combined with the access-right note, an agent has enough to call it and set expectations, with only the failure behavior for missing access left unstated.

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 robot_id parameter, so the description must carry the load. It conveys that the tool operates on exactly one robot and that a per-robot access right is checked, which implicitly clarifies robot_id semantics, but gives no format guidance or example.

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 (analysis) and resource (geopolitical and supply chain dependency profile) scoped to one robot and grounded in the mechanical BOM. The 'mechanical BOM' anchor implicitly distinguishes it from hardware_get_dependency_profile and software_get_dependency_profile, though no sibling is named explicitly.

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

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

The description implies the use case (assessing geographic concentration, critical raw materials, single-source exposure for one robot) and states a prerequisite (access right on the robot), but never says when to choose this over software_get_dependency_profile or hardware_get_dependency_profile. Routing must be inferred from the domain prefix and 'mechanical BOM'.

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, non-destructive, closed-world, so the safety profile is covered. The description usefully adds what is returned (specs, pricing, viability score, mechanical status) and clarifies overlapping content across variants, but it leaves 'mechanical-profile status' undefined and the 'layer flag' claim has no counterpart in the schema.

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 tight sentences, with the payload described first and the cross-variant relationship second. The only waste is the 'layer flag' remark, which points at a concept the schema doesn't expose.

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 read tool with annotations covering safety and no output schema, the description does enough to convey what comes back. It falls short on the one input parameter and on what 'mechanical-profile status' actually contains.

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 is one required parameter (robot_id) with 0% schema description coverage, and the description says nothing about it - no identifier format, source, or whether it's an internal or vendor ID. The one piece of semantic guidance an agent needs here is absent.

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 resource and payload: the commercial profile of one robot (specs, pricing, viability score) plus mechanical-profile status. It also distinguishes itself from the other get_robot variants, though the reference to a 'layer flag' is confusing since no such parameter exists in the schema.

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

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

The note that 'commercial fields are identical in all three get_robot variants' implies the choice hinges on which layer's status you need, but it never explicitly says 'use this when you need mechanical status; use hardware_get_robot or software_get_robot otherwise.' Usage is inferable rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description still earns credit by disclosing the authorization requirement and the exact refusal behavior, which no annotation conveys. It stops short of describing pagination or response shape.

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 resource definition and followed by the access constraint. The component list is a slight enumeration tax but doubles as a useful content preview, so it 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?

With no output schema, the description does well to enumerate what the BOM contains. However, blocks_only is left undefined and there is no disambiguation from the mechanical_get_robot sibling, so an agent could still call the wrong tool or pass the wrong flag.

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 bears the full burden and does not meet it. It never mentions robot_id explicitly as the selector, and blocks_only — a boolean filter that materially changes the output — is completely unexplained in both schema and description.

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?

Names a specific resource (mechanical bill of materials for one robot) and enumerates its components, so an agent knows exactly what comes back. It does not, however, distinguish itself from the sibling mechanical_get_robot, which an agent could reasonably assume returns something similar.

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 supplies a prerequisite (access right on the requested robot) and the failure mode (refusal naming the robot), which is genuinely actionable. But it never says when to pick this over mechanical_get_robot, hardware_get_robot_hardware, or mechanical_get_block_analysis — the agent must infer that from the tool name alone.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds two pieces of context the annotations do not carry: an authorization requirement tied to the specific robot, and the fact that only 'active' signals are returned (a filtering behavior, not a full history). Return shape and pagination remain unstated.

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

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

Two short sentences with zero filler: the purpose is stated first, then the access prerequisite. Nothing is repeated from the title or schema.

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?

It is a simple read-only tool with annotations covering the safety profile and no output schema to explain, which keeps the bar modest. However, with no output schema and 0% parameter coverage, the undefined include_global flag and the unstated notion of what a 'signal' contains leave real gaps for an agent about to call it.

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

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

Schema description coverage is 0% for both parameters. The description hints that robot_id selects a single robot, but include_global (default true) is entirely unexplained — an agent cannot tell whether toggling it widens scope to fleet-wide signals or filters them out. With near-zero schema coverage, the description needed to compensate and does not.

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 gives a specific verb ('signals affecting') and a clearly bounded resource: one robot's mechanical BOM, with the adverb 'active' narrowing the result set. It implicitly separates itself from mechanical_list_signals by scope (single robot vs. list), but never names that sibling explicitly, so it sits just below the top tier.

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 only explicit guidance is a prerequisite: an access right on the requested robot. There is no statement of when to prefer this over mechanical_list_signals, hardware_get_robot_signals, or software_get_robot_signals, so the agent must infer from the domain prefix.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds value beyond that by disclosing what the report contains (profile load state, signal counts, load errors) - effectively substituting for the missing output schema. It does not say whether load errors are blocking or how failures surface, keeping it from a 5.

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

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

Two short sentences, zero filler, and the core resource identity is front-loaded before the sibling disambiguation. Every clause 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?

With no parameters and no output schema, the description carries the return-value burden and does so at a summary level (profiles, counts, errors). Combined with fully specified annotations, an agent has enough to call it correctly; only the shape/format of the status payload is unspecified, which is minor for a no-arg status check.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter claims are made or contradicted.

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 resource (the MECHANICAL layer's health) and enumerates the concrete contents: profiles loaded, signal counts, load errors. The second sentence explicitly distinguishes it from the hardware_ and software_ status siblings, so an agent can route correctly without opening any schema.

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

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

The line 'One status tool per layer - the three report different layers, not the same server' tells the agent exactly which sibling to pick and why they are not interchangeable. It lacks an explicit 'do not use when' clause or a pointer to the layer-specific detail tools (mechanical_list_robots, mechanical_get_robot_signals), which is the only gap.

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, non-destructive, closed-world, so the safety profile is covered. The description adds a genuinely useful non-obvious trait: all three variant tools return the identical catalogue, which prevents redundant calls. It says nothing about default result size, pagination behaviour, or ordering, which matter for a list tool with limit/offset.

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 scope, the deduplication rule, and the selection rule front-loaded in that order. No filler and nothing repeated from the title or annotations.

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?

Routing and duplication behaviour are well covered, but this is an 8-parameter tool with no output schema and zero parameter documentation, and the description addresses roughly two of those parameters only vaguely. An agent still has to guess at filtering and paging semantics, so the definition is not complete enough to invoke confidently.

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

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

Schema description coverage is 0% for 8 parameters, so the description must carry the burden and does not. It alludes to status and payload filters, but leaves `pays`, `categorie`, `min_score`, `in_scope_only`, and the limit/offset paging semantics — including the meaning of the -1 sentinel on min_score and min_payload — entirely unexplained.

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

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

States a specific verb and resource (list the robot catalogue) plus the filtering axis (mechanical-profile status and payload), and explicitly distinguishes itself from the hardware and software list variants. An agent can identify this tool without opening the schema.

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

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

"Returns the same catalogue as the hardware and software variants - call one, not three" is unusually strong routing guidance, and "pick this one to filter on mechanical coverage" gives an explicit selection condition. It stops short of naming `hardware_list_robots`/`software_list_robots` directly and gives no when-not-to-use case beyond the variant 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 readOnly, idempotent, non-destructive and closed-world, so the safety profile is fully covered. The description adds a genuinely useful non-annotated behavior: it is panel-wide and requires an access right on at least one robot, which affects whether a call will fail. It does not cover pagination behavior or defaults, which keeps it below a 5.

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

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

Two short sentences, front-loaded with the resource and scope. Every clause carries information and nothing is padded or restated from the title.

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 an 8-parameter tool with no output schema, no enums and zero schema descriptions, the definition is materially incomplete: the filter vocabulary, accepted severities/signal types, and pagination semantics are absent. Annotations cover the safety profile, but an agent cannot construct a targeted query from this description alone.

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

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

All 8 parameters have 0% schema description coverage, so the description carries the full burden of explaining them. It only says 'with filters' and never names a single filter (region, block_id, active_only, signal_type, min_severity, component_type) or explains limit/offset. The agent must guess the meaning and accepted values of every argument.

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 (List) and resource (mechanical supply chain, performance and operational signals) plus the scope (across the panel). The clause 'Panel-wide, not per robot' distinguishes it from the sibling mechanical_get_robot_signals, so an agent can pick correctly without opening either schema.

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

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

Usage context is implied by 'Panel-wide, not per robot' and the access prerequisite, which steers an agent away from the per-robot variant. However, no sibling is named explicitly (hardware_list_signals, software_list_signals), and there is no statement of when this feed is the right choice versus the domain-specific bundles.

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/non-destructive, but the description adds genuinely new behavior: authorization is required per-robot, the operation is all-or-nothing, and a refusal names the offending robot and compares nothing. That atomic-failure semantic is exactly the kind of thing annotations cannot convey.

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, no filler. The capability statement is front-loaded and the precondition/failure mode follows, which is the right order for an agent deciding whether to call.

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

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

No output schema exists, and the description compensates by naming the compared dimensions, so the agent knows roughly what comes back. The precondition and failure behavior are covered; the only material omission is the input format for multiple robot IDs.

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

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

Schema coverage is 0% and robot_ids is an undescribed string, so the description carries the burden. It contributes the cardinality bound (2 to 5), but never specifies the encoding of multiple IDs in a single string parameter (comma-separated? array-like?), leaving a real ambiguity for the caller.

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 (compare), a bounded resource set (2 to 5 robots), and enumerates the exact comparison dimensions: software BOM, TCO, jurisdiction exposure, lock-in, export control risk. The 'software' domain plus those dimensions distinguish it cleanly from hardware_compare_robots and mechanical_compare_robots without needing to name them.

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

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

Gives a clear triggering condition (side-by-side comparison of 2-5 robots in the software domain) and a hard prerequisite (access right on every listed robot). It does not explicitly route the agent to the hardware/mechanical siblings when the domain differs, so the exclusion is implied by the title rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds real context beyond that: an authorization prerequisite (access right on the named robot, or on at least one robot when none is given) and a per-robot scope limit. It does not describe what the analysis returns or its size/shape.

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 with no filler; the scope constraint is front-loaded immediately after the purpose. The trailing clause 'when none is' is slightly elliptical but the total length is well matched to the tool's simplicity.

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, non-destructive two-parameter tool with full annotation coverage this is close to sufficient, but with no output schema the description never indicates what a 'block analysis' actually yields, and it leaves the robot_id-omitted behavior to inference.

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 carry the parameters. It partly does: the parenthetical block list effectively enumerates valid block_id values, and 'when none is [named]' signals robot_id is optional and falls back to a broader scope. But it never states the block_id format, what happens when robot_id is omitted (aggregate across robots?), or the difference in result for each case.

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 ('Analyse') and a specific resource ('one software block'), and enumerates the block domains (OS, middleware, runtime, control, fleet), which separates it from hardware_get_block_analysis and mechanical_get_block_analysis via the software domain prefix. It never names a sibling explicitly, so differentiation is by domain naming rather than routing.

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 'for a single robot at a time' constraint and the access-right prerequisite imply when the tool applies, but there is no explicit guidance on when to prefer it over software_get_dependency_profile, software_get_robot_software, or software_get_system_status, nor any stated exclusion.

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, non-destructive, closed-world behavior, so the remaining burden is low. The description adds a genuine non-schema fact: an access right on the requested robot is required. It stops short of stating failure modes or rate limits, so not a 5.

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 filler, and the analytic scope is front-loaded ahead of the access prerequisite. Everything stated 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?

With no output schema, the description usefully names what the profile contains (jurisdiction concentration, lock-in, export control, cloud dependency) and the auth precondition. It could say more about the response shape or what a robot_id looks like, but an agent has enough 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?

Single parameter with 0% schema description coverage, so the description must compensate. 'for one robot' and 'access right on the robot requested' do imply that robot_id identifies a single robot and requires permission on that specific one, but no format or ID-source guidance is given.

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 ('dependency analysis ... for one robot, built on its software stack') and enumerates the four analysis dimensions (jurisdiction concentration, lock-in, export control, cloud dependency). The 'software' qualifier clearly separates it from the hardware_ and mechanical_ dependency-profile 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?

Implies usage via 'for one robot' and names the access-right prerequisite, but never says when to prefer this over hardware_get_dependency_profile, mechanical_get_dependency_profile, or software_compare_robots, nor any when-not 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?

Annotations already declare readOnly, idempotent, closed-world, non-destructive, so the safety profile is covered. The description adds useful content context — that the commercial block is invariant across the three variants — but says nothing about auth requirements, failure behavior for unknown IDs, or the 'profile status' semantics.

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

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

Two short sentences, front-loaded with what is returned, followed by the disambiguating note. No filler.

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

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

For a single-param read tool with no output schema and full annotation coverage, the description adequately names the returned fields and the variant relationship. The remaining gap is the undocumented robot_id format and the dangling 'layer flag' reference.

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?

Only one parameter (robot_id) and schema coverage is 0%, so the description must carry the load; it says 'one robot' but never explains the ID format or where to obtain it (e.g., software_list_robots). The mention of a 'layer flag' as the variant difference is also confusing since no such parameter exists in the schema.

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

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

States a concrete verb/resource ('commercial profile of one robot') and enumerates the payload: specs, pricing, viability score, software tier, profile status. It also distinguishes itself from the hardware/mechanical get_robot variants by saying the commercial fields are identical and only the layer differs, though it references 'the layer flag' rather than naming the sibling 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?

Implicitly tells the agent to pick this variant for the software layer, but never says when to prefer it over software_get_robot_software, software_get_robot_signals, or software_compare_robots. There is no explicit when-to-use or when-not phrasing, only the variant-identity note.

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, non-destructive and closed-world, so the safety profile is covered. The description adds a real behavioral detail the annotations do not carry: an access right is required on the requested robot. It still leaves 'active' undefined and says nothing about result volume or scoping.

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

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

Two short sentences with no waste, and the resource scope leads before the access prerequisite. Nothing padding, though it is arguably too terse for the gaps it leaves.

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

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

With no output schema and no descriptions on either parameter, the description is the only prose available and it stops at scope plus auth. It should at minimum define 'active' and explain include_global's default-on behavior, which materially changes the returned signal set.

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, and it only obliquely justifies robot_id ('one robot's software stack'). The include_global parameter (default true) is entirely unexplained, leaving the agent unable to know whether global-level signals are included or how to exclude them.

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

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

The description names a specific resource: active supply chain signals scoped to one robot's software stack. This implicitly distinguishes it from the hardware_ and mechanical_ signal siblings, but it does not explicitly contrast with software_list_signals, so the boundary is inferred rather than stated.

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

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

There is no when-to-use guidance, no exclusions, and no alternative tool named. An agent must guess whether to use this or software_list_signals to find the same information, and nothing says what 'active' excludes.

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 establish readOnly, idempotent, non-destructive, and closed-world, so the description correctly avoids restating those. It adds genuinely new behavior: an access right on the target robot is required and a refusal naming that robot is returned if absent — useful failure-mode context an agent would otherwise not predict.

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 tight sentences: the payload description is front-loaded and the access/refusal caveat follows. No filler, though the refusal clause is arguably more operationally important than the component list and could lead.

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

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

With no output schema, the description does well to enumerate which software layers come back. But the undocumented blocks_only flag and the unstated relationship to sibling BOM/analysis tools leave meaningful gaps for a 2-parameter tool with zero schema coverage.

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 carries full responsibility for both parameters and delivers neither. robot_id is only obliquely implied ('one robot'), and blocks_only — a non-default flag that clearly changes the response — is never mentioned, leaving an agent unable to judge what it does.

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?

Names a specific resource — the software BOM for a single robot — and enumerates the layers it covers (OS, middleware, AI runtime, motion control, fleet management). It separates itself from hardware_/mechanical_ siblings by domain, but does not distinguish itself from close relatives like software_get_robot or software_get_block_analysis.

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

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

Usage is only implied by the phrase 'for one robot'; there is no explicit statement of when to pick this over software_get_robot, software_get_dependency_profile, or software_get_block_analysis. The one concrete condition given is an access precondition, not a routing rule.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds value beyond that by disclosing the content of the health report (profiles loaded, signal counts, load errors), which tells an agent what evidence a 'healthy/degraded' read will actually surface.

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

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

Two short sentences, front-loaded with the resource and its contents, followed by the sibling disambiguation. No filler or restatement of the title.

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 parameters, no output schema and full annotation coverage, the description supplies the essential missing context: what 'status' means here and how it differs from the two other layer-status tools. It stops short of saying how the health is summarized or whether load errors are truncated, which would complete the picture.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the schema already covers the empty argument object at 100% coverage. Baseline 4 applies.

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

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

Names the resource and scope precisely ('Health of the SOFTWARE layer') and enumerates what the report contains: software profiles loaded, signal counts, load errors. It also explicitly differentiates from the sibling layer-status tools (hardware_get_system_status, mechanical_get_system_status) by stating they report different layers of 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 sentence 'One status tool per layer - the three report different layers, not the same server' effectively routes an agent: pick this one when the question concerns the software layer, and do not assume the siblings duplicate it. No explicit when-not or prerequisite guidance, but the disambiguation is 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 readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds genuinely useful context that it returns the same catalogue as the hardware/mechanical variants. It does not describe pagination behavior or the effect of in_scope_only defaults, leaving gaps for a read 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?

Two tight sentences, front-loaded with the action and its distinguishing scope, followed by the family-routing rule. No filler.

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

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

With 8 undocumented parameters, no output schema, and opaque names like pays, min_score and in_scope_only, the description leaves too much undefined for an agent to filter reliably. It should at least explain the non-obvious filters and default behavior.

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

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

Eight parameters at 0% schema description coverage, so the description carries the full burden. It only clarifies software_tier (and implies status via 'software-profile status'); pays, limit, offset, categorie, min_score and in_scope_only are entirely undocumented anywhere.

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

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

States a specific verb and resource ('List the robot catalogue with filters') and explicitly names the distinguishing scope: filtering by software tier and software-profile status. The sibling variants (hardware/mechanical) are named so an agent can tell them apart without opening schemas.

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

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

Explicitly routes the agent: 'call one, not three' and 'Pick this one to filter by software tier'. That is a clear selection criterion against the hardware/mechanical siblings. It lacks guidance on when to prefer the catalog variants over the *_get_robot tools, but the within-family routing is strong.

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, so the safety profile is covered. The description adds something the annotations do not: an authorization precondition and the aggregate-across-panel semantics, which materially affects how results should be interpreted.

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 waste; the scope statement and the access precondition are both front-loaded before any reader could form wrong assumptions.

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 nine-parameter filtering tool with no output schema and no parameter descriptions, the definition omits the two things an agent most needs: what the filter values look like and what the feed returns. Authorization and scope are covered well, but the filtering surface is left entirely to guesswork.

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 nine parameters, so the description carries the full burden and compensates only with the generic word "filters." It never explains what domain, signal_type, jurisdiction, min_severity, component_type, active_only, or the limit/offset paging pair actually do.

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 concrete verb and resource ("List software supply chain signals") and pins down scope as panel-wide, which distinguishes it from the per-robot siblings like software_get_robot_signals and from hardware_/mechanical_list_signals by domain. It stops short of naming a sibling explicitly, so an agent must infer the family split from the software_ prefix.

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?

"Panel-wide, not per robot" is an explicit usage boundary plus the prerequisite "requires an access right on at least one robot," which tells the agent both when to pick this tool and what gates it. There is no guidance on when to prefer the per-robot variant or on how to page through large result sets.

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