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

Annotations already cover read-only and idempotent behavior, so the description does not need to restate safety. It adds useful behavioral context by specifying that events are split into cutting vs non-cutting time and that air-time opportunities are identified. It does not mention edge cases or limitations, but none are critical given the strong annotation coverage.

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

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

The description is one tight sentence with no filler and front-loads the primary action. It is appropriately concise, though slightly terse given the parameter count and the need for usage differentiation.

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 output schema exists and the annotations cover side effects, so return values and safety do not need elaboration. However, the description omits when to prefer this tool over estimate_cycle_time and does not clarify the key threshold/rate parameters, leaving moderate ambiguity for an agent.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It loosely maps to 'events' and 'air-time opportunities', but it does not explain machineRapidRate, defaultToolChangeSeconds, or opportunityThresholdSeconds, nor their units, defaults, or roles.

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

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

The description uses a specific verb ('Decompose') and names the exact resource ('supplied motion/events') and output ('cutting and non-cutting time', 'reviewable air-time opportunities'). It clearly distinguishes from generic simulation tools, but it does not explicitly contrast with likely siblings like estimate_cycle_time or analyze_toolpath_risk.

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

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

The description gives no guidance on when to use this tool versus alternatives such as estimate_cycle_time or analyze_toolpath_risk. It implies the input is a list of motion/events, but there is no explicit context, prerequisite, or exclusion statement.

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 read-only, idempotent, and non-destructive behavior. The description adds meaningful scope context: it covers only bounded linear motion, flags unsupported motion, and returns 'reviewable' cycle-time evidence rather than a raw estimate. No contradiction with the annotations.

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

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

A single sentence with no filler. The verb and primary resource are front-loaded, and the output categories are listed compactly. Every phrase contributes meaning.

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

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

Given the complexity (14 parameters, nested objects, 0% schema description coverage) and the close sibling tools, the description is too thin. It leaves 'bounded' unexplained, gives no guidance on required inputs, and does not route an agent toward or away from analysis siblings. The output schema covers return values, but the input and selection context are incomplete.

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

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

Schema description coverage is 0% for 14 parameters, so the description carries the burden of explaining inputs. It does not mention program, units, coordinateFrame, initialPosition, machine, or any other parameter. Terms like 'feed/spindle limits' and 'rapid' only loosely map to machine fields, but this is insufficient for a parameter-rich 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 specific verb and resource ('Parse bounded G-code linear motion') and lists concrete outputs ('flag risky rapids, feed/spindle limits, unsupported motion, and reviewable cycle-time evidence'). The scope is clear enough to distinguish it from siblings like analyze_cycle_time and analyze_toolpath_risk.

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 a use case: analyzing a G-code program for motion risks and cycle-time evidence. However, it does not explicitly state when to use this tool versus closely related siblings like analyze_toolpath_risk or analyze_cycle_time, and it provides no exclusions or alternative 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 indicate read-only, idempotent, and non-destructive behavior, so the description only needs to add context beyond that. It adds the semantic scope and the 'human review' purpose, which is useful, but it does not describe specific behavioral details such as output shape, ordering, or how displayLimit affects results.

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

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

The description is a single, tightly packed sentence with no filler. The main verb and core object are front-loaded, and every word adds meaning.

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

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

The output schema covers return values and annotations cover side effects, but several gaps remain: `displayLimit` semantics are absent, parameter mapping from description to schema is only implicit, and the description does not explicitly disambiguate this tool from closely related siblings like compare_nc_files or analyze_nc_program.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It indirectly maps 'baseline' to `before` and 'changes' to `after`, but it never explicitly describes either parameter, and `displayLimit` is 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?

The description uses a specific verb ('risk-rank') and a precise object ('semantic NC changes') scoped to an 'approved baseline' and intended purpose ('human review'). This clearly differentiates it from sibling tools like compare_nc_files or analyze_nc_program, which perform related but different tasks.

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 a clear use case: run this when there are semantic NC changes to be risk-ranked against an approved baseline for human review. It does not explicitly name alternatives or state when not to use it, but the context is discernible enough for an agent to select it appropriately.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description does not contradict these, but it also adds little beyond the basic operation. It does mention 'direct and transitive' which is useful, but does not disclose any additional behavioral traits such as output size limits, performance characteristics, or side effects beyond what annotations would imply. Given the annotations cover safety, this is acceptable but not exceptional.

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

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

The description is a single, focused sentence that front-loads the core action. There is no redundancy or extraneous detail, making it highly efficient and easy to parse. It earns its place fully.

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 an output schema present, the return value structure is covered. However, the description does not provide usage context, prerequisites, or explanation of the two required parameters. It lacks explicit guidance on when to choose this tool over alternatives, and the parameter semantics gap makes it incomplete for an agent to correctly invoke it without additional schema inspection.

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 of explaining parameters. However, it does not explain what 'operations' or 'changedOperationIds' mean, how they are used, or any constraints (e.g., the structure of 'dependencies'). The agent must infer the parameter semantics from the overall purpose, which is insufficient for a tool with this complexity.

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

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

The description clearly states a specific verb ('trace') and a specific resource ('operation dependencies affected by a programming change'). It distinguishes this tool from sibling analysis tools like get_dirty_toolpaths or verify_change by focusing on transitive impact rather than direct state or validation. The purpose is unambiguous and actionable.

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 when to use this tool (when a programming change occurs and you need to know affected operations) but does not explicitly state when not to use it or mention alternatives. It lacks guidance on how this differs from get_dirty_toolpaths or verify_change, leaving the agent to infer the appropriate context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds no additional behavioral context beyond the word 'Check', which is largely redundant with those annotations. It does not mention whether the analysis mutates state, requires a running session, or how risks are reported.

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

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

A single sentence, front-loaded with the verb and resource, followed by a compact list of risk types. No filler words or redundant elaboration. Every word earns its place.

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

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

The tool has a complex schema with 7 parameters-the input is a large array of segments and machine definition. The description indicates what the tool checks, and an output schema exists to document return values. However, it does not clarify how risks are reported, what thresholds apply, or whether optional parameters like safeZ and safetyMargin affect the analysis. Adequate but minimal for a tool with this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It does mention risk categories that loosely map to parameters (e.g., 'approach-angle' hints maxApproachAngleDeg, 'fixture-envelope' hints fixtures, 'travel' hints machine.travel), but it does not explicitly connect parameters to the listed checks. With 7 parameters including nested machine and segment objects, the agent must rely on property names alone for meaning.

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

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

The description uses a specific verb ('Check') and identifies the exact resource ('supplied toolpath segments') plus six concrete risk categories (travel, rapid, fixture-envelope, limit, approach-angle). This clearly distinguishes it from sibling tools like get_operation_risks or detect_collisions, which focus on different scopes or output formats.

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

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

No guidance is given on when to use this tool versus alternatives such as get_operation_risks, detect_collisions, or get_toolpath_status. The context signals show many nearby tools with overlapping analysis themes, and the description does not provide selection criteria, prerequisites, or exclusions.

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

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

Annotations already mark the tool as destructive, and the description adds a non-obvious behavior: stale state is rejected. It also implies an authorization requirement via the approval token. No contradiction with annotations.

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

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

The description is a single front-loaded sentence with no filler. The action, token requirement, and stale-state guard are all communicated efficiently.

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 core apply action, token requirement, and stale-state guard are covered, and the output schema handles return-value details. The main gap is the unexplained idempotencyKey, which matters for retry semantics.

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

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

Schema description coverage is 0%, so the description must compensate. It explains approvalToken's role as the token from a previewed change, but it says nothing about the optional idempotencyKey, leaving its purpose entirely to inference.

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

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

The description states a specific action ('Apply'), a specific resource ('previewed change'), and the required credential ('approval token'). It also distinguishes the tool from preview-oriented siblings by framing it as the application step.

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

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

'Using its approval token' clearly establishes the prerequisite: the tool is used after a preview has produced a token. 'Refuses stale state' gives a condition for failure, but it does not explicitly name alternatives such as preview_operation_parameters or rollback_change.

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

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

The annotations already convey that the operation is read-only, idempotent, and non-destructive, and the description does not contradict them. However, the description adds no additional behavioral context, such as what happens when the assertion fails, what scope the check covers, or any subtle side effects.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. It is efficient, though its brevity contributes to the ambiguity penalized in other dimensions.

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

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

Although annotations and an output schema reduce the burden, an agent still lacks essential context: which operation the assertion applies to, how path and equals interact, and what 'measured value' means in the Mastercam domain. This is insufficient for a tool with three parameters and no parameter-level descriptions.

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

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

With 0% schema description coverage, the description must compensate by explaining the parameters, but it only hints at the concept of 'expected value' (equals) and 'measured value' (path). It does not clarify that path identifies where the measured value comes from or what operationId refers to.

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

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

The description states a clear action: verifying that a measured value matches an expected value. It is more informative than the bare name 'assert', but 'measured value' is somewhat vague and it does not explicitly distinguish itself from similar sibling tools like verify_change or inspect.

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

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

No guidance is given for when to use this tool versus alternatives such as inspect, measure, or verify_change. There are no conditions, prerequisites, or exclusions, so the intended usage must be inferred from the tool name and schema.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds that this is a pure calculation tool producing tap drill, RPM, and feed, but it does not mention assumptions, unit expectations, or how constraints like threadPercent are applied.

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

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

The description is a single sentence with the verb and resource front-loaded, and it wastes no words. The ambiguous 'grounded' is a minor clarity issue, but structurally the description is appropriately compact.

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

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

For a tool with six parameters, a nested geometry object, enums, defaults, and numeric constraints, the one-line description leaves too much to inference. The output schema covers return values, but input semantics, required geometry subfields, and calculation assumptions are under-specified.

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

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

Schema description coverage is 0%, so the description needs to compensate, but it only loosely maps 'metric or unified' to the system parameter and 'supplied geometry' to the geometry object. It does not explain threadPercent, tapType, cuttingSpeed, or the relationships among pitch, tpi, callout, and nominalDiameter, leaving most parameter semantics to the agent's inference.

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 ('Calculate'), a clear resource ('thread/tapping geometry'), and the scope ('metric or unified'), while also naming the expected outputs: tap drill, RPM, and feed. The word 'grounded' is ambiguous, but the overall purpose is clear and distinguishes this from the other inspection and planning tools in the sibling list.

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 description: an agent should call this when it has supplied geometry and needs thread/tapping calculations. However, there are no explicit when-to-use or when-not-to-use conditions, and no alternative tools are named, leaving the decision to inference rather than direct guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context, such as how the image is returned or whether it is saved to disk. Since annotations cover the key behaviors, a score of 3 is appropriate—consistent but not enriching.

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

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

A single, front-loaded sentence with no extraneous words. It states the core action and target directly, achieving maximum 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?

The tool is simple with no required parameters and an output schema present, so the return format is presumably covered by the schema. The description adequately conveys the primary purpose. Minor ambiguity around 'bounded' and the exact context of the graphics window exists, but given the low complexity and existing annotations, it is sufficiently complete.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It does not mention width, height, or format at all. Although the schema provides defaults, enums, and bounds, the description adds zero value to parameter semantics. For a low-coverage case, this is a significant 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?

The description clearly states the action (capture) and the resource (bounded view image of the Mastercam graphics window). It is specific and distinguishes itself from the sibling tools, which are mostly about operations, toolpaths, and analysis. There is no ambiguity about what this tool does.

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

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

No explicit guidance on when to use this tool versus alternatives is given. However, the tool's function is unique among siblings, so the context is implied. The description does not mention when not to use it or any prerequisites, leaving the agent to infer usage from the purpose 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds domain context but no behavioral detail about what is checked, what readiness means, or what the validation result implies.

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

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

A single five-word sentence states the core purpose with no redundancy and no wasted words. It is front-loaded and appropriately sized for a zero-parameter check.

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 validation tool with an output schema, the description is nearly sufficient. The main gap is a fuller explanation of what 'client configuration readiness' entails and how the result is reported, but the output schema likely covers some of that.

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

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

The tool has zero parameters, so the schema is trivially complete with 100% coverage. The description need not elaborate on arguments, and the no-parameter baseline of 4 applies.

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

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

The description uses the specific verb 'Validate' and names the resource as 'client configuration readiness,' which distinguishes it from machine-profile or toolpath validation siblings. It could be more explicit about what readiness means, but the core purpose is clear.

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

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

The description gives no guidance on when to use this tool over siblings like validate_machine_profile or manufacturing_preflight. The only signal is the name and generic validation framing, leaving 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which cover the safety profile. The description adds that it performs sequence diffing and produces a semantic summary, which gives some insight into behavior beyond the annotations, but it doesn't discuss limitations, input size constraints, or output characteristics.

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

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

The description is a single sentence that front-loads the action and resource, with no wasted words. It efficiently conveys the core purpose and method.

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

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

The description is minimal for a tool with 2 parameters and an output schema. It lacks usage guidance, parameter format details, and explanation of the output structure. While the output schema exists, the description does not help the agent understand what the semantic summary contains or how to interpret the diff. It is too sparse for a tool that compares potentially large NC files.

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%, but the description states 'Compare two NC files', which clarifies that the 'before' and 'after' parameters are NC file contents. This adds meaning to otherwise bare string parameters, though it doesn't specify format, encoding, or how the files should be provided (e.g., paths vs. content).

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

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

The description clearly states the verb 'Compare' and the resource 'two NC files', and specifies the method as 'sequence diffing and semantic summary'. This distinguishes it from sibling compare tools like compare_toolpaths or compare_tool_databases by the explicit 'NC files' focus, though it could be more explicit about the differentiation.

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

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

There is no guidance on when to use this tool versus alternatives such as compare_toolpaths or compare_tool_databases. The description does not mention prerequisites, context, or situations where this tool is preferred over others.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the qualifier 'semantically' but does not explain what that entails or any other behavioral traits (e.g., how comparison results are presented). It does not contradict the annotations.

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

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

The description is a single, well-structured sentence that states the core purpose without fluff. It is front-loaded with the action and object, though it is so terse that it skips essential details. It earns its place but could be more informative without losing conciseness.

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

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

Although an output schema exists, the description omits critical information: parameter formats, what 'semantically' means, and any usage context. An agent cannot reliably call this tool without additional clarification, making the definition incomplete for its purpose.

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% – the parameters 'left' and 'right' have empty schemas with no types or descriptions. The description implies they are the two tool database snapshots but gives no format, structure, or how to provide them (e.g., file paths, objects). This fails to compensate for the schema's lack of detail.

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

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

The description clearly states the verb 'compare' and the resource 'tool database snapshots', which distinguishes it from sibling tools like compare_toolpaths or compare_nc_files. The qualifier 'semantically' adds nuance but is not fully explained. Overall, the purpose is 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?

There is no guidance on when to use this tool versus the many sibling comparison tools (e.g., compare_toolpaths, compare_nc_files). No mention of prerequisites, input formats, or exclusions, leaving the agent to guess the appropriate context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no additional behavioral context beyond the verb 'compare', which aligns with the read-only hint, but does not disclose output format or side effects. No contradiction exists.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for the limited content, though it under-specifies important details, making it efficient but incomplete.

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

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

Although an output schema exists, the description does not indicate what the comparison yields or how to interpret results. Given the tool's specificity and the presence of many sibling comparison tools, more context about the comparison mechanism or when to use it would be expected. The description alone is insufficient for an agent to fully understand the tool's behavior.

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

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

The schema has 0% description coverage, and the description does not explain the two required parameters (beforeOperationId, afterOperationId). While the parameter names are somewhat self-explanatory, the description fails to clarify their semantic meaning or the order relationship, leaving the agent without sufficient guidance for correct invocation.

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

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

The description clearly states the action (compare) and the resource (two operations' toolpaths), and it is distinct from sibling tools like compare_tool_databases and compare_nc_files. However, it does not specify the nature of the comparison (e.g., visual diff, textual output), which would enhance clarity.

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

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

No guidance is given on when to use this tool versus alternatives or any prerequisites. The description implies comparison of toolpaths but does not explain context, such as whether the operations must be generated first or how this differs from other comparison 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 cover the safety profile (read-only, non-destructive), and the description does not contradict them. It adds a small scoping detail—that detection applies to selected operations—but provides no further behavioral context such as whether it consumes the current selection or how results are reported. With annotations present, the bar is lower, and this meets it minimally.

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

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

The description is a single, tightly worded sentence with no filler or redundant phrasing. It is front-loaded with the action and scoped with the target. It is somewhat under-specified, but as far as conciseness goes, 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?

Given that the input schema is empty, an output schema exists, and annotations cover safety, the core call shape is understandable. However, the description omits usage guidance and does not explain the dependency on current selection or how results are provided. It is minimally adequate but leaves meaningful context gaps.

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

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

The input schema has zero parameters, so the baseline is 4. The description adds useful implicit meaning by indicating that the tool operates on 'selected operations,' which clarifies that the relevant selection state is external to the schema. It does not fully explain how selection is established, but it still adds value beyond the empty schema.

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

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

The description clearly states the action ('Run collision detection') and the target resource ('selected operations'), making the tool's core purpose identifiable. It does not explicitly distinguish itself from similar analysis tools like analyze_toolpath_risk or run_simulation, so it stops short of a 5.

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

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

There is no guidance about when to use this tool versus siblings such as analyze_toolpath_risk, verify_change, or run_simulation. The phrase 'selected operations' implies a prerequisite, but it is never stated explicitly, and no alternative tools or exclusions are mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by stating the output is grouped by workflow stage, which is not present in the annotations or 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?

The description is a single front-loaded sentence with no filler: 'Show available capabilities grouped by workflow stage.' It is appropriately sized for a simple read-only discovery tool, though it sacrifices detail for brevity.

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

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

The core behavior is stated and the output schema covers return values, but the description leaves the optional category parameter undocumented and does not clarify when to choose this tool over sibling capability/help tools. It is minimally viable but not fully complete for agents that need to filter or disambiguate.

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

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

The schema contains one optional parameter, category, with no description and 0% schema description coverage. The description does not mention this parameter, how it filters results, or how it relates to workflow-stage grouping, leaving the agent without enough information to use the filter correctly.

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

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

The description uses a concrete verb-plus-resource statement, 'Show available capabilities grouped by workflow stage', with an explicit organizing principle. It is distinguishable from sibling capability tools like mastercam_capabilities by the workflow-stage grouping, though it does not explicitly name any alternative.

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 a usage context through 'grouped by workflow stage', suggesting stage-oriented capability discovery, but it gives no explicit when-to-use or when-not-to-use guidance and names no alternatives. Given the large sibling set, this leaves overlap with tools like mastercam_capabilities or list_tool_categories unresolved.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no extra behavioral context, such as prerequisites (e.g., requiring an active selection) or how the estimate is derived. It relies entirely on the minimal phrase, which doesn't disclose anything beyond the annotations.

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

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

The description is a single short sentence with zero extraneous words. It is front-loaded with the verb and resource, making it highly concise and structurally efficient.

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

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

The presence of an output schema covers return values, and the single-parameter complexity is low. However, the description omits any usage context, such as whether a selection is required, how it relates to 'analyze_cycle_time', or any assumptions about the current part state. For a tool with such minimal description, this is a noticeable gap.

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

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

The schema has 0% description coverage for the single parameter 'operationIds', and the description does not elaborate on it. While the parameter name is somewhat self-explanatory (an array of operation IDs), the description doesn't confirm its meaning, format, or constraints, leaving a gap that the schema also fails to fill.

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

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

The description uses a specific verb ('Estimate') and resource ('cycle time for selected operations'), making the primary function clear. However, it doesn't differentiate from the sibling tool 'analyze_cycle_time', which likely serves a similar purpose, so it's not fully distinctive.

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

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

No guidance is provided on when to use this tool versus alternatives like 'analyze_cycle_time' or when not to use it. The description leaves the selection criteria entirely to the agent's 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a minor nuance that it works from 'actual returned parameters', implying it may depend on prior calls, but it does not disclose any other behavioral details like response format or side effects.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the core action and is appropriately sized for its limited content.

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

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

Despite having an output schema, the description lacks critical context: it does not clarify what kind of explanation is produced, nor does it specify when to choose this tool over the many operation-related siblings. The term 'actual returned parameters' is ambiguous without more context, leaving the agent under-informed.

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

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

Schema description coverage is 0%, so the description must compensate, but it adds nothing about the operationId parameter beyond the obvious 'an operation'. It does not explain what 'actual returned parameters' means in relation to the parameter or how the ID is used to produce the explanation.

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

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

The description uses a clear verb 'Explain' with a resource 'operation', and specifies a source ('from its actual returned parameters'), which distinguishes it from simple fetch tools like get_operation or get_operation_parameters. However, it does not define what 'explain' entails (e.g., natural-language reasoning, diagnostics), so it is not fully precise.

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

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

There is no guidance on when to use this tool versus its many siblings such as get_operation, get_operation_parameters, or preview_operation_parameters. No conditions, prerequisites, or exclusions are given, leaving the agent to guess the appropriate context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no further behavioral context—no mention of pagination, sorting, or that it returns a filtered list. Given the annotations, the bar is lower, and the description is neutral and consistent, but it doesn't disclose anything beyond what annotations already imply.

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

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

The description is a single concise sentence that front-loads the verb and resource. It contains zero wasted words and immediately communicates the core function. This is excellent for quick parsing by an agent.

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

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

For a search tool with 4 optional parameters and an output schema, the description is minimal but arguably sufficient for basic usage. However, it omits any hint about the limit parameter, default behavior, or how multiple filters interact. Since the output schema exists, return values are covered, but the description doesn't fully equip an agent to use the tool optimally in all scenarios, especially given the many sibling tools.

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

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

With schema description coverage at 0%, the description must compensate. It mentions 'name, type, or tool number' which maps to query, operationType, and toolNumber, but provides no details on how these parameters behave—e.g., whether query is a substring match, case sensitivity, or how they combine. The limit parameter is not mentioned at all. The description only lists search dimensions without semantic depth.

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

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

The description clearly states the tool's function: searching operations by name, type, or tool number. It uses a specific verb ('Search') and resource ('operations') and lists the key search dimensions. While it doesn't explicitly differentiate from sibling tools like list_operations or get_operation, the name and description make the search/filter intent evident.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention that list_operations lists all operations or that get_operation fetches a specific one, nor does it state any conditions under which find_operations is preferred. Users must infer usage from the name and description.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which cover the safety and side-effect profile. The description adds no behavioral context beyond that, such as what happens to the inputs, whether any state changes occur, or any authentication or rate-limit requirements. Since the annotations already carry the key traits, the description does not contradict but also contributes nothing extra.

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

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

The description is a single sentence with no extraneous words. It front-loads the core action and resources. There is no fluff or redundancy, making it highly concise and easy to parse.

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

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

Given the tool's complexity (9 parameters, all optional, nested objects, and no schema coverage), the description is grossly incomplete. It does not explain the output format (even though an output schema exists), the meaning of each input, the relationship between the parameters, or any usage constraints. An agent cannot correctly construct a call without additional investigation.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It vaguely references 'operation tree and tool records', which maps to the 'operations' and 'tools' parameters, but it provides no detail on the remaining seven parameters (wcs, part, stock, machine, notes, verification, setupReferences). For a complex tool with 9 nested parameters, this is insufficient.

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

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

The description states a clear verb ('Generate') and a resource ('setup and operation notes') and mentions the primary inputs ('operation tree and tool records'). It is unambiguous about the tool's core function. However, it does not differentiate from the sibling tool 'generate_setup_sheet', which is likely similar in purpose, so it misses an opportunity to distinguish itself.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, scenarios, or exclusions. The sibling 'generate_setup_sheet' is not referenced, and no context is given about when one should be chosen over the other. This leaves the agent to infer usage.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds only the 'revision-ready' output characteristic and the inspection-data input source; it does not reveal other behaviors such as output format or how omitted inputs are handled.

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

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

The description is one short, front-loaded sentence with the verb first and the deliverable immediately visible. Every word adds context ('revision-ready', 'from inspection data') and there is no redundant content.

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

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

Despite the output schema, the input-side context is severely incomplete: seven unnamed nested object/array parameters can be passed but the description does not explain their roles, constraints beyond schema limits, or what makes a setup sheet 'revision-ready'. An agent cannot confidently assemble a valid call from this definition alone.

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

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

Schema description coverage is 0% and the tool has seven parameters, but the description does not explain any of them. 'From inspection data' is too generic to cover wcs, part, notes, stock, tools, machine, and operations, so the description fails to compensate for the schema's lack of parameter documentation.

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

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

The description states a specific action ('Create') and a clear deliverable ('revision-ready setup sheet'), sourced from 'inspection data'. This is enough to distinguish it from the sibling generate_operation_packet, which targets a different packet type.

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

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

The phrase 'from inspection data' implies the tool should be used when an inspection-based setup sheet is needed, but the description never explicitly says when to use it versus alternatives. No exclusions or sibling routing are provided, so the guidance remains implicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to restate that this is a safe read operation. It adds the qualifier 'active' to indicate it targets the current document, which is useful behavioral context beyond the schema. However, it does not disclose what kind of inspection is performed, what data is returned, or any side effects (though there are none). The description is consistent with annotations, so no contradiction.

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

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

The description is a single, compact sentence that front-loads the verb and resource. It contains no filler or redundant phrasing. Every word earns its place, and it is appropriately sized for a tool with no parameters and simple semantics.

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, no-parameter tool with an output schema (which presumably details the return structure), the description is largely complete. An agent knows it inspects the active part document and that it is safe. However, given the large sibling list, a more explicit note about what kind of inspection (e.g., 'returns a summary of the part's properties') would help an agent decide when to call it. Still, the simplicity and annotation coverage make it sufficient 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?

The tool has zero parameters, so the input schema is empty and schema description coverage is 100% (trivially). The baseline for no parameters is 4, and the description does not need to add parameter semantics. It does not introduce any confusion, and the description's focus on the resource ('active part document') is sufficient.

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

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

The description states a clear verb ('Inspect') and a specific resource ('the active Mastercam part document'), which makes the tool's purpose unambiguous. It does not explicitly differentiate from the many sibling inspection tools (e.g., get_geometry_summary, get_selection), but the 'active part document' scope is distinct enough that a capable agent can infer its role. It is not a tautology and is more specific than a generic 'inspect'.

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

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

The description provides no guidance on when to use this tool versus any of the numerous sibling tools that also inspect parts or geometries. It does not mention alternatives, exclusions, or any context such as 'use this to get the current part's overall status' or 'prefer get_geometry_summary for detailed geometry'. An agent is left to guess when this is the right 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 the operation read-only, idempotent, and non-destructive. The description adds some useful context by characterizing the audit log as append-only and mentioning that the current document revision is included, but it does not disclose details like how results are ordered, whether the limit affects the returned entries, or whether the log is scoped to the current document.

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

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

The description is a single concise sentence with no filler or repetition. The key resource is front-loaded, though the verb 'Describe' could be more precise.

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 tool with one optional parameter and an output schema, the description conveys the general purpose, but it leaves ambiguity around whether the tool returns a summary or actual audit entries, and it omits how the `limit` parameter interacts with the audit log. The output schema covers return structure, but the description alone is not fully sufficient 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?

The schema description coverage is 0% and the description does not mention the `limit` parameter at all. Although the parameter is self-explanatory and the schema provides default/min/max constraints, the description fails to compensate for the missing schema descriptions, which is the stated requirement when coverage is low.

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

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

The description identifies a specific resource—the append-only audit log—and the current document revision, which is distinct from the sibling tools. The verb 'Describe' is slightly ambiguous because the tool name implies retrieving history, but the resource scope is clear enough for an agent to distinguish it from other tools.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, no exclusions, and no preferred context. An agent must infer from the name and the phrase 'audit log' that this is for inspecting history, but no direct usage guidance is given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no extra behavioral context beyond 'Show', which aligns with annotations. No contradictions, but no added value either.

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

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

The description is a single, clear sentence with no filler. It front-loads the action and resource. It is appropriately concise, though it could benefit from a bit more specificity.

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 presence of an output schema covers return format. However, the description does not explain what 'compatibility matrix' specifically entails (e.g., which Mastercam versions, how verification status is determined) or how it relates to similar tools like get_version_report. For a no-param read-only tool, it is minimally adequate but leaves some ambiguity.

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

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

With zero parameters, the schema is complete and the description need not explain parameters. Baseline 4 applies because there is nothing to add; the tool is parameterless.

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

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

The description states a clear action ('Show') and a specific resource ('supported Mastercam releases and verification status'). It is distinct enough from most siblings, though it doesn't explicitly differentiate from closely related tools like get_version_report or mastercam_status.

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

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

There is no guidance on when to use this tool versus alternatives. Given the large sibling list with overlapping capabilities (mastercam_status, get_version_report), the absence of usage context leaves the agent to infer which tool is appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The phrase 'preserve unknown state' adds little beyond those annotations, and no extra behavioral details like performance or side effects are disclosed.

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

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

The description is a single concise sentence that front-loads the main action and condition. The 'preserve unknown state' phrase is slightly redundant, but overall the description is efficient and to the point.

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

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

The tool has an output schema that presumably covers return format, but the description lacks usage guidance and parameter semantics. It does not explain what 'dirty state' means or how behavior changes when operationIds is omitted, leaving the agent with significant gaps in understanding.

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

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

Schema description coverage is 0% and the description never mentions the operationIds parameter. Since the schema only provides the name and type, the description does not clarify how the parameter filters results or its optional semantics, failing to compensate for the low coverage.

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

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

The description clearly states the tool lists operations whose mapped dirty state requires regeneration, which is a specific verb-resource combination with a filtering condition. It distinguishes from generic list_operations by the dirty-state criterion, though it does not explicitly contrast with siblings like get_toolpath_status.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_operations or get_toolpath_status. It does not mention use cases, prerequisites, or exclusions, leaving the agent to infer when this is the right 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 disclose readOnly, idempotent, and non-destructive behavior, so the bar for additional disclosure is lower. The description adds that the output will cover limitations, which gives some context about the nature of the result, but it doesn't elaborate on side effects, prerequisites, or other behavioral traits beyond what annotations already cover.

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

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

The description is a single, tightly written sentence that states the core purpose and the added value ('limitations') without any fluff. Every word earns its place, and the key resource is front-loaded.

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

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

For a zero-parameter tool with a rich output schema and safety annotations, the description is nearly sufficient. The only minor gap is that 'limitations' is left ambiguous – it could be clarified whether these are limitations of the fixture backend's capabilities, accuracy, or something else – but this is a small concern given the output schema will define the structure.

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

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

The tool has zero parameters, and schema coverage is 100% (empty schema), so there are no parameter semantics to explain. Per the baseline rule for zero-parameter tools, a score of 4 is appropriate; the description doesn't need to add anything about inputs.

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

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

The description uses a specific verb ('Describe') with a clear resource ('the active fixture backend') and adds a distinctive qualifier ('and its limitations'). It is immediately distinguishable from all sibling tools, none of which reference fixtures, so an agent can select it confidently.

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

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

The description provides no explicit guidance on when to invoke this tool versus alternatives. There are no conditions, alternatives named, or exclusions given; the agent must infer that it should be used when fixture backend information is needed, which is implied but not 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the 'without dumping entities' context, which clarifies the operation's lightweight nature, but does not disclose details like whether it applies to the active part or selected geometry, or any rate limits. The added value is modest but consistent.

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

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

The description is a single, front-loaded sentence that states the core purpose and a key differentiator in under 10 words. There is no filler or redundancy; every word earns its place.

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

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

With 0% schema coverage and no mention of operationId, the description leaves a gap in parameter understanding. Additionally, 'geometry' is ambiguous—it could refer to selected entities, active part, or something else. The presence of an output schema helps for return values, but the missing parameter semantics and ambiguous resource scope make the definition incomplete for a tool with even one parameter.

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 of explaining the operationId parameter. The description does not mention operationId at all, leaving its purpose to inference. For a single optional parameter this is a notable gap, though the parameter name is self-explanatory to an extent.

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

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

The description uses a specific verb ('Summarize') and identifies the resource ('geometry') and the exact outputs ('counts and bounding box'). The phrase 'without dumping entities' explicitly distinguishes it from sibling tools like get_selected_entities that return full entity data. This makes the tool's purpose unambiguous.

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

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

The description implies usage when only a summary is needed ('without dumping entities'), but it does not name specific alternative tools or state when not to use this tool. It offers a hint of lighter-weight operation but lacks explicit routing to alternatives like get_selected_entities or get_operation.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds the scope of what context is returned but no additional behavioral traits such as snapshot behavior, cost, or relationship to get_programming_context. No contradiction with annotations.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes meaning by enumerating the four context areas, which is appropriately sized for a zero-parameter tool.

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

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

With zero parameters, strong annotations, and an output schema present, the description is largely sufficient for invocation. The only notable gap is the lack of guidance on how this aggregate relates to its granular siblings, but that gap is mostly a usage-guideline concern.

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. The description's list of returned context domains clarifies what the parameterless call provides, but there is no parameter-level semantics to enrich.

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

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

The description uses a clear verb ('Return') and names four concrete context domains: machine, stock, workholding, and coordinate. It conveys that this is an aggregate context getter, but it does not explicitly differentiate itself from sibling tools like get_stock, get_wcs, or get_fixture_info.

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

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

The description gives no indication of when to call this aggregate tool instead of the more granular sibling tools. There are no alternatives, exclusions, or contextual triggers mentioned, leaving the agent to infer usage from the tool name and the sibling list.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is fully covered. The description adds the alias relationship, which is useful identity context, but does not disclose additional behavioral details such as pagination, auth requirements, or response characteristics; there is no contradiction with the annotations.

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

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

The description is extremely compact: a front-loaded imperative verb and resource, followed by a single clarifying parenthetical. Every word earns its place and no filler is present.

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 alias tool with an output schema and rich annotations, the description is complete. The alias reference to list_machine_groups provides all the contextual linkage an agent needs to select and call this tool correctly.

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

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

The input schema has zero parameters and schema description coverage is 100%, so there are no parameter meanings for the description to add. The baseline of 4 for a no-parameter tool applies here.

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 the exact action and resource ('List machine groups') and further clarifies the tool's identity by naming it as an alias of list_machine_groups. This makes its purpose unmistakable and distinguishes it from the otherwise similar sibling without requiring schema inspection.

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

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

The description provides clear context by explicitly tying the tool to list_machine_groups as an alias, so an agent knows it can be used in exactly the same situations. It does not articulate explicit when-not conditions, but for a zero-parameter alias, the context is sufficiently clear and no exclusions are necessary.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds a useful behavioral constraint ('no fallback targeting'), but it does not disclose what happens for a missing or invalid id, which would add further transparency.

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

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

One concise, front-loaded sentence with no filler. Every word adds meaning, and the key scoping constraint ('exact id; no fallback targeting') is placed immediately after the verb.

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-only getter with an output schema and safety annotations, the description is nearly complete. It lacks only explicit guidance on when to use sibling tools or what happens when the operation does not exist.

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%, but the single parameter is self-explanatory from its name and type. The description reinforces that operationId must be an exact id rather than a search term, yet it does not explain where the id comes from or how invalid ids are handled.

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

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

The description states a specific verb and resource: 'Retrieve one operation by exact id'. 'One' and 'exact id' distinguish it from list/find/explain siblings, and 'no fallback targeting' clarifies it is not a fuzzy lookup.

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 right usage: call this when you already have an exact operationId and need that single operation. However, it does not explicitly mention alternatives such as find_operations or explain_operation, or state when those should be preferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'proven' qualifier and 'exact id' semantics, suggesting a validated, exact-match lookup, but does not disclose additional behaviors such as error conditions or prerequisites.

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

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

The description is a single sentence with no filler words. It front-loads the verb and keeps the key qualifiers ('proven', 'exact id') tight, making it easy to scan.

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?

This is a simple one-parameter read operation with rich annotations and an output schema, so the description covers the core invocation semantics. It could be better by mentioning how to obtain the operationId (e.g., from list_operations), but that is more of a usage-guideline gap than a fundamental completeness gap.

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

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

Schema description coverage is 0%, so the description must carry the parameter meaning. The phrase 'by exact id' indicates operationId is an exact-match identifier, but it does not explain what an operation ID is or how to obtain it, leaving the parameter semantics only partially clarified.

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 ('retrieve'), resource ('one operation's proven parameters'), and method ('by exact id'). It is clear about what the tool does, but it does not explicitly distinguish it from sibling tools like get_operation or preview_operation_parameters.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention that a user should call this when they need proven parameters for a specific operation, nor does it point to siblings like list_operations or get_operation for finding IDs.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds no behavioral context beyond the purpose itself, such as what 'verification scope' means or what kind of risks are reported.

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

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

The description is a single, compact sentence with no filler. It is front-loaded with the action and object, though the phrase 'verification scope' could be more concrete.

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 presence of an output schema covers return values, but the description is too terse to fully orient an agent among many risk/analysis siblings. It lacks explanation of the key concept 'verification scope' and does not clarify when this tool is the right choice.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented operationId parameter. It vaguely refers to 'an operation' but does not explain the meaning of operationId or any relationship to the parameter, leaving the agent to rely on the parameter name.

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

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

The description uses a specific verb ('Report') and names the resource ('operation risks'), making the basic purpose clear. However, 'verification scope' is vague and the description does not distinguish this from sibling tools like analyze_toolpath_risk or detect_collisions.

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

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

No guidance is given on when to use this tool versus alternatives, nor any conditions or exclusions. The agent is left to infer usage from the name and description alone.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully carried by structured data. The description adds only the 'assigned' scope qualifier and no further behavioral context, such as behavior when no post processor is assigned. No contradiction with the annotations exists.

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

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

The description is a single seven-word sentence stating the action and target with no filler, redundancy, or secondary clauses. For a zero-parameter tool, this is appropriately sized and 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 parameters, an output schema present to document return values, and annotations covering the read-only/idempotent behavior, the description is nearly complete for a tool of this simplicity. The only minor gap is that 'assigned' is not explicitly defined (assigned to the active part, the machine context, or the current job), though sibling-tool naming largely disambiguates this.

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

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

The tool has zero parameters and the schema coverage is trivially 100%, so a per-parameter explanation is unnecessary. Per the rubric, the baseline for a no-parameter tool is 4, and the description has no parameter-information burden to satisfy.

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

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

The description uses a specific verb ('Report') and a clearly defined resource ('assigned post processor metadata'), immediately distinguishing it from sibling metadata tools like get_version_report, get_fixture_info, or get_machine_context. The qualifier 'assigned' narrows the scope to the currently-configured post processor rather than a broad catalog query.

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

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

There is no guidance about when to call this tool versus any alternative, and no conditions or exclusions are given. The description does not name sibling tools as fallbacks (e.g., get_machine_context) for cases where the post processor assignment is unknown, leaving the decision entirely to the agent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that the result is 'bounded' and includes 'explicit unknowns,' a useful hint about response behavior, but does not explain freshness, failure modes, or what 'bounded' concretely limits.

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

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

The description is a single concise sentence with no filler; the key resource and its main qualifiers are front-loaded. The list of contents is dense and somewhat jargon-heavy, but every word contributes.

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 an output schema and strong annotations, the return contract and safety profile are covered, so the description only needs to clarify purpose and invocation context. It does not give enough usage context to distinguish this bundled snapshot from the many sibling getters, leaving the agent to guess when this tool is the right choice.

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

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

The input schema has one optional boolean, includeGeometry, with no description (0% coverage), and the tool description never mentions it. The parameter name is fairly self-explanatory, but the description provides no additional meaning about when to set it or what geometry it adds.

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

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

The description identifies the resource as a 'Bounded live/fixture context bundle' and enumerates its contents (operations, referenced tools, revision, coverage, explicit unknowns), so an agent can infer it returns a context snapshot. However, it is a noun phrase with no explicit verb and does not position itself against sibling getters like get_machine_context or get_fixture_info.

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

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

No guidance is given about when to call this tool or which sibling to prefer. The description only names the bundle contents; it does not mention alternatives, exclusions, or the relationship to get_fixture_info/get_machine_context.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds no additional behavioral context such as ordering, grouping details, or whether it can return an empty result, but it does not contradict the annotations either.

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

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

The description is a single, efficient sentence with no fluff. The core action and grouping behavior are front-loaded, making it easy to scan and understand.

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

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

For a tool with no parameters, an output schema, and simple read-only semantics, the description is fully sufficient. It tells the agent exactly what the tool reports, and the annotations cover safety and idempotency. Nothing essential is missing.

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

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

The tool has zero parameters and an empty input schema, so there is no parameter documentation burden on the description. Per the rubric, a zero-parameter tool receives a baseline of 4, and the description does not need to compensate for missing parameter information.

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

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

The description uses a clear verb ('report'), a specific resource ('selected entities'), and a distinguishing qualifier ('grouped by type'). This differentiates it from sibling tools like get_selection, which likely returns the raw selection. The purpose is immediately understandable and distinct.

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

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

No guidance is given about when to use this tool versus alternatives such as get_selection or get_geometry_summary. The description states what it does but does not mention any exclusions, prerequisites, or context that would help an agent choose it over related 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 readOnlyHint=true and idempotentHint=true, so the safety profile is established. The description adds the scope (operations) but does not disclose additional behaviors such as whether the selection is session-persistent, how empty selections are handled, or the exact return format (though output schema exists). Given the annotations, a 3 is appropriate.

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

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

The description is a single, concise sentence that is front-loaded and contains no filler. It efficiently communicates the tool's 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?

For a tool with no parameters and an output schema, the description is adequate for an agent to understand what it does. The lack of usage guidance is a minor gap given the simplicity, but the description is otherwise complete.

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

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

There are zero parameters, so the schema fully covers parameter semantics. The baseline for 0 params is 4, and the description adds no redundant parameter information.

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

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

The description uses the specific verb 'Report' and the resource 'currently selected operations', making the tool's purpose clear. It does not explicitly distinguish itself from the sibling tool get_selected_entities, but the resource specificity (operations vs. entities) provides implicit differentiation.

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

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

There is no guidance on when to use this tool versus alternatives like get_selected_entities or list_operations. The description does not mention any selection prerequisites, typical scenarios, or exclusions, leaving the agent to infer usage context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description aligns with these annotations and adds that the report covers 'definition and units', but it does not disclose any behavior beyond that. No annotation contradiction exists.

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

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

The description is a single, tightly scoped sentence with no filler or repetition. It front-loads the core purpose and earns every word.

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 tool with an output schema present, the description is minimally sufficient. It states what the agent can expect to retrieve. The only gap is the lack of an explicit 'current' or 'active' qualifier, but the getter pattern and tool name make that reasonably inferable.

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

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

With zero parameters and 100% schema description coverage, there is no parameter documentation burden on the description. The phrase 'definition and units' hints at the content of the response, which is helpful but not required.

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

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

The description uses a specific verb, 'Report', and names the resource: 'stock definition and units'. This makes it clear it is a read-only getter for stock data, and distinguishable from sibling tools like get_tool or get_operation. It is not a full 5 because it does not explicitly clarify what 'stock' refers to in context.

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

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

The description provides no guidance on when to use this tool versus alternatives like get_geometry_summary or get_active_part. There is no mention of when-not-to-use, and the intended invocation context is left entirely 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 cover read-only, idempotent, and non-destructive behavior, so the description's burden is lighter. It adds useful context about the identifier types (id, number, exact name) and the 'active-operation tool' scope, which is beyond structured data. However, it does not describe error behavior, output format, or any limits, which would have added more transparency.

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

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

The description is one concise sentence of 13 words. It leads with the verb and resource, then states the lookup modes. There is no padding or repetition; every word adds value.

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

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

Given the tool's simplicity, the presence of an output schema, and safety annotations, the description is mostly adequate. The main gaps are the ambiguous term 'referenced' and no clarification of what an 'active-operation tool' is or behavior on a not-found lookup. For a single-parameter retrieval tool, this is acceptable but not complete.

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

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

With 0% schema description coverage, the description must explain the parameter's meaning, and it does. It says 'toolId' can be an id, number, or exact name, giving semantic context beyond the raw string/integer union in the schema. This is a meaningful compensation for a single-parameter tool, though it could be more specific about domain identifier formats.

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

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

The description uses the specific verb 'Retrieve' and clearly identifies the resource as 'one referenced active-operation tool', distinguishing it from list_tools (which lists tools) and get_operation (which deals with operations). It also specifies the lookup keys (id, number, exact name), making the purpose concrete. The term 'referenced active-operation' is slightly ambiguous, but for a domain-aware agent the intent is clear.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like list_tools or find_operations. It implies a single-tool lookup, but it does not state when to choose it over a list or search tool, and no sibling tools are referenced. This leaves the agent to infer usage context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds value by naming the tri-state output (dirty/current/unknown), but it does not explain behavior for unmapped operations or invalid operation IDs. There is no contradiction with the annotations.

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

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

A single, front-loaded sentence with no filler. Every word contributes meaning, and the core state values are stated compactly.

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?

This is a low-complexity tool with one parameter, a rich annotation set, and an output schema. The description sufficiently communicates the tool's purpose and key state vocabulary; the only notable gap is the undefined 'mapped' concept, which is minor given the output schema likely documents the result structure.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented operationId parameter. It only says 'for an operation,' which weakly implies what operationId refers to, but it does not clarify how to obtain it, what 'mapped' means, or how the parameter relates to the reported status.

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

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

The description uses a specific verb ('Report') and a clear resource: the dirty/current/unknown state of a mapped toolpath for an operation. It is clear but does not explicitly differentiate itself from siblings like get_dirty_toolpaths, which could appear to overlap.

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 tool is used when you need toolpath status for a specific operation, but it provides no explicit guidance on when to choose this over get_dirty_toolpaths, get_operation, or other status-related tools. No alternatives or exclusions are mentioned.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only the word 'detected', hinting at some discovery process, but never explains what is scanned (registry, files, installed versions), how the report is produced, or what 'compatibility' means. With a 0-param tool and no output schema details, the description carries the behavioral burden and largely fails to meet it.

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

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

The description is a single short fragment, so it is undeniably concise and front-loaded. But it borders on under-specification: one terse sentence that adds little beyond the tool's name and offers no meaningful detail. It earns a middle score for brevity without substance.

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

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

Although an output schema exists (lightening the return-value burden), the description is too thin to orient an agent. It fails to explain what the report contains, how detection works, or how this differs from get_compatibility_matrix. For a diagnostic tool among a large sibling set, more context is needed.

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

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

The tool has zero parameters and 100% schema coverage, so there is nothing for the description to document. Per the baseline for 0-param tools, this dimension scores well because no parameter clarification is needed.

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

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

The description names the resource (Mastercam and NET-Hook compatibility) and the action (report), which gives the tool an identifiable purpose. However, it's a sentence fragment that reads more like a label than a definition, and it doesn't differentiate this from closely-related siblings such as get_compatibility_matrix or mastercam_capabilities, both of which plausibly overlap with a 'compatibility' report.

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

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

There is no guidance on when to call this tool versus the many alternatives. Among 65+ siblings, get_compatibility_matrix and mastercam_status are natural competitors, yet the description gives the agent no cue for choosing between them, nor any conditions or prerequisites.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds no further behavioral context beyond the fact that it reports current state, which is sufficient given the annotation coverage.

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

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

The description is a single concise sentence with no filler. It immediately communicates the tool's purpose and contains no redundant information.

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

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

With no parameters, full annotation coverage, and an output schema present, the description is complete for an agent to understand what this tool does and invoke it correctly. No additional context is necessary.

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

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

The tool has zero parameters and schema coverage is 100%, so there are no parameter semantics for the description to clarify. The baseline of 4 for no-parameter tools applies.

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

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

The description uses a specific verb ('Report') and a specific resource ('active work coordinate system'). This clearly distinguishes the tool from siblings like get_machine_context or get_programming_context, whose scopes are different.

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

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

There is no guidance on when to use this tool versus alternatives such as get_machine_context or get_active_part. The intended use is only implied by the name and description, not explicitly 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 readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds little beyond 'return its current values' and does not disclose behavior like how path relates to operationId, what happens when the target is missing, or any resolution 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?

The description is a single short sentence with no filler, front-loading the core action. It is concise, although the brevity comes at the cost of substance that other dimensions need.

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

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

An output schema exists, so return-value details are covered elsewhere, but the core ambiguity of 'target' and the meaning of the parameters remain unresolved. Given the large sibling set and minimal parameter documentation, the description is not complete enough for reliable tool selection and 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?

Schema description coverage is 0% and the description provides no information about operationId or path beyond the schema's bare names and types. It does not explain which parameter identifies the target or how the optional path modifies the lookup, so an agent has no semantic guidance.

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

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

The description states a clear action ('inspect') and a resource ('target'), but 'target' is undefined and could refer to any entity. It does not distinguish this tool from the many getter siblings like get_operation, get_selection, or get_wcs.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusions, and no context about suitable scenarios. The sibling list is large and includes many similar read tools, so the absence of routing guidance is a notable 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'in the document' scoping, which is useful context. It does not disclose additional behavioral details such as whether the tool returns only the active group or all groups, but the annotations lower the burden here.

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

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

The description is one short, front-loaded sentence with no filler. Every word contributes to the meaning: 'List', 'machine groups', and 'in the document'. It is concise without sacrificing clarity.

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

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

For a simple, zero-parameter, read-only tool with an output schema and strong annotations, the description is largely complete. The only meaningful contextual gap is the lack of differentiation from get_machine_groups, which prevents full completeness in the broader sibling context.

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

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

This tool has zero parameters and the schema coverage is 100%, so there is no parameter semantics burden on the description. With no parameters to explain, the description cannot add parameter-level value; the baseline for zero-parameter tools is appropriate.

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

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

The description uses a specific verb and resource: 'List machine groups in the document.' It clearly states the operation and scope. However, it does not distinguish itself from the closely named sibling get_machine_groups, so an agent cannot tell which tool to prefer without further schema inspection.

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

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

No guidance is given about when to use this tool versus get_machine_groups or other sibling tools. The description implies 'list all machine groups in the document' but does not state exclusions or alternatives. This is a notable gap because the sibling set contains a very similar-looking tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds 'explicit quantities and pagination', which gives some behavioral context about the output style. However, it doesn't explain what 'explicit quantities' means (e.g., does it return counts?) or how pagination behaves. Given the annotations, the description provides marginal extra value beyond them, warranting a 3.

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

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

The description is a single short sentence, which is concise and front-loaded. However, it is under-specified, providing only the core action and a hint of behavior. While conciseness is good, the lack of substance makes it less effective. An ideal description would be slightly longer to cover filtering and pagination details without becoming verbose.

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

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

Given the tool has three parameters, 0% schema description coverage, and many sibling tools, the description is incomplete. It fails to explain operationType, the meaning of limit/offset, or how this tool differs from find_operations. An output schema exists, so return values need not be described, but the absence of any parameter or usage context makes this inadequate for an agent to call 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?

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It mentions pagination but does not define limit or offset semantics, and it completely ignores operationType, which appears to be a filter. The description adds no meaning to the parameters beyond what the schema already shows (e.g., types and defaults). With three parameters and zero coverage, this is a clear failure.

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

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

The description clearly states a verb ('List') and a resource ('operations'), which gives a clear purpose. It doesn't explicitly distinguish itself from sibling tools like find_operations, but the phrase 'explicit quantities and pagination' hints at a distinct scope. A clear purpose with minor lack of sibling differentiation merits a 4.

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

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

The description provides no guidance on when to use this tool versus alternatives such as find_operations, get_operation, or list_tools. It mentions pagination and quantities, which implies a batch listing scenario, but there is no explicit when-to-use or when-not-to-use guidance. This is a significant gap given the large set of sibling tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds the category taxonomy, which is useful context, but does not disclose anything further about behavior such as ordering, filtering behavior, or result structure.

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

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

The description is a single concise sentence that leads with the action and immediately specifies the category scope. Every word earns its place, with no filler or repetition of the tool name.

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

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

For a zero-parameter, read-only listing tool with an output schema and clear annotations, the description provides enough context. It names the categories and the operation, and the output schema covers return structure.

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

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

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics for the description to clarify. The description appropriately does not invent parameter guidance.

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

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

The description names a specific verb (List), a specific resource (tools), and enumerates the exact category scope: read, preview, write, advanced, and forbidden. This clearly distinguishes the tool from siblings like list_tools and get_tool by emphasizing category-based organization.

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

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

There is no guidance on when to use this tool versus alternatives such as list_tools or discover_capabilities. The description only implies that this is the tool for viewing tool categories, but it does not state exclusions or trade-offs.

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