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

With no annotations, the description carries the full burden. It implies a read/validation operation but doesn't state whether it mutates data, what happens when variants fail the audit, whether rate limits or pagination apply (the maxVariants param hints at scale), or what auth is needed. This leaves meaningful behavioral gaps for a 5-param tool.

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

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

A single, efficient sentence with no filler. However, for a tool with five parameters and no annotations, this brevity is under-specification rather than genuine conciseness.

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

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

For a 5-parameter, no-annotation, no-output-schema tool with 0% schema description coverage, the description is far too thin. It omits parameter meanings, return values, side effects, and usage context, leaving an agent unable to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for five undocumented parameters. It explains none of them: productGroupId, locationId, maxVariants (with default 250 and max 500), includeInactive, and baselineProductId. The mention of a 'manufacturing baseline' hints at baselineProductId, but that weak connection 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?

States a specific verb (audit/validate) acting on variants, an option matrix, and a manufacturing baseline. It is a validation operation, distinguishable from sibling mutations like set_product_group_config or create_product_group_variants. However, 'audit' is slightly abstract and the description doesn't clarify whether it returns findings or fixes anything, which would sharpen it against siblings.

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

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

No guidance on when to use this tool versus alternatives like compare_product_boms or get_product_group_variant_quantities. An agent cannot tell from the description whether this is a pre-flight check, a data repair, or a reporting call.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only, non-destructive calculation but never says so, and it discloses nothing about truncation behavior (maxDepth/maxProducts caps), how stockBasis affects results, or what the computation returns.

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

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

A single front-loaded sentence with no filler. It is appropriately short, though its brevity is partly a symptom of under-specification rather than discipline.

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 7-parameter computation tool with no annotations and no output schema, the description is far too thin. An agent cannot determine depth/limit semantics, stock basis behavior, or expected result shape from what is given.

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

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

Schema description coverage is 0% across 7 parameters. The description names the three mode values, which covers one enum, but says nothing about stockBasis (available vs onHand), maxDepth/maxProducts limits, or that buildQuantity is a decimal-string quantity. Most parameter meaning is left undocumented in both schema and description.

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

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

States a specific verb (calculate) and resource (BOM requirements), and enumerates the three modes (direct, leaf, net), which sets it apart from get_bill_of_materials and compare_product_boms. It stops short of explicitly naming those siblings, so it is clear but not fully differentiated.

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 indication of when to use this over get_bill_of_materials, compare_product_boms, or get_inventory_summary, no stated prerequisites (e.g., an existing BOM and configured manufacturing config), and no exclusions. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. 'Compare' implies a non-mutating read, but nothing states the return shape, ordering, error behavior when an ID is invalid, or cost/rate characteristics given the 25-product cap.

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 efficient sentence with the action front-loaded and the cardinality constraint attached. No filler, though the brevity contributes to the gaps elsewhere.

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 annotations, no output schema, and a completely undocumented parameter, the description leaves the agent without return-format, error, or ID-format information. It is too thin for the complexity of a multi-product comparison.

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

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

Only one parameter (productIds) with 0% schema description coverage, so the schema itself explains nothing about format or meaning. The description's '2-25 products' merely restates the schema's minItems/maxItems and adds no semantics about ID form, existence requirements, or duplicate handling.

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

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

States a specific verb ('Compare') and the compared resources ('manufacturing components, operations, and settings') scoped to products, which separates it from read-oriented siblings like get_bill_of_materials or get_product. 'Settings' is somewhat vague, but the core action and domain are unambiguous.

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

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

No guidance on when to choose this over fetching each product's BOM individually, no prerequisites, and no mention of what conditions make comparison appropriate. The 2-25 bound implies batch use but is not framed as usage guidance.

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

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

With no annotations, the description carries the full burden. It does disclose two non-obvious traits: source row IDs are not reused, and apply is gated on a fresh preview's exact scope plus confirmation hash. It does not say what replace mode does to the target's existing config, whether the change is reversible, or what permissions are needed.

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

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

Two dense sentences with no filler, and the preview-vs-apply constraint is front-loaded in the second sentence. Slightly compressed relative to the amount of behavior an agent still needs.

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 high-complexity mutation with a nested confirmation object, 18 parameters, no annotations, and no output schema. The description covers the preview/apply gate but omits the semantic difference between modes, the meaning of the confirmation fields, and the consequences of applying, leaving significant gaps for an agent.

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

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

Schema description coverage is 0% across 18 parameters, so the description must compensate. It hints at sections and the confirmation scope/hash, but leaves mode (patch vs replace), dryRun, previewToken, idempotencyKey, allowInactiveComponents, and the eight expected* hash parameters entirely unexplained.

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

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

States a specific verb pair (preview/copy) and resource (manufacturing sections from one product to another), and the 'without reusing source row IDs' clause signals a distinct behavior. It is distinguishable from set_product_manufacturing_config and audit_product_group_manufacturing, but it never names a sibling to sharpen the boundary.

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 two-phase workflow (preview first, then apply with the returned scope and hash), which is useful invocation guidance. However, it gives no explicit when-to-use/when-not direction versus the nearby set_product_manufacturing_config, compare_product_boms, or audit_product_group_manufacturing.

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

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

With no annotations, the description carries the full behavioral burden. It discloses deterministic ID generation and a saga pattern, but omits critical details like the dryRun default, what previewToken is for, idempotency requirements, and how the expected hash fields affect safety. The opacity around 'canary' leaves the apply flow unexplained.

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

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

Two concise sentences with no filler, and the core action is front-loaded. The brevity is appropriate structurally, though the content is too sparse to be fully useful.

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 a complex mutation tool with 9 parameters, nested arrays, no output schema, and no annotations, the description is severely incomplete. It provides high-level saga context but leaves the agent unable to call the tool correctly without guessing at core behaviors.

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 mentions no parameters at all. With 9 parameters including required nested variants and hash fields, the description does nothing to explain their meaning or usage.

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 ('Preview') and resource ('product/variant IDs'), but the phrase 'compensated create-and-attach saga' is opaque jargon that obscures whether the tool creates, previews, or does both. It does not clearly distinguish itself from siblings like create_product_group_variants or set_product_group_config.

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 explicit guidance on when to use this tool versus alternatives. The clause 'Apply stays blocked until its canary' hints at a precondition for a subsequent apply, but does not tell an agent when previewing is appropriate or what canary means in practice.

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

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

With no annotations, the description carries the full burden and discloses critical traits: it is a legacy immediate write, high risk, and bypasses INFLOW_ENABLE_SAFE_WRITES. It does not state irreversibility or permission requirements, but the risk profile is unusually well surfaced for a delete tool.

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

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

Two sentences, zero waste, with the critical risk warning and deprecation notice front-loaded before the core purpose. Every element earns its place.

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

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

For a simple one-parameter delete tool with no output schema and rich schema coverage, the description gives all needed context: what it does, why it is risky, and which alternative to use. Nothing an agent needs to decide or call correctly 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?

Schema coverage is 100% (single parameter webhookId with a clear description), so the schema already fully documents the parameter. The description adds no syntax or format detail beyond what the schema provides, making the baseline 3 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?

States a specific verb and resource ('Delete a webhook subscription') and explicitly names the preferred sibling tool ('Use remove_webhook instead'), so an agent can distinguish this legacy tool from its replacement without opening either schema.

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

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

Provides explicit when-to-use guidance by stating 'Use remove_webhook instead' and warns of high risk and safe-write bypass, which functions as a clear 'do not use unless...' condition. No inference required.

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

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

With no annotations, the description carries the full burden, and it does disclose two real behavioral traits: the result is 'stable' (a deterministic snapshot rather than a live recomputation) and it includes 'concurrency metadata' (implying an optimistic-concurrency token). It still omits whether the call is read-only, what happens for an unknown productId, and any auth or rate-limit notes.

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

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

A single front-loaded sentence with no filler; the return-content list is compact and informative. It is appropriately sized for the tool's simplicity.

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

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

There is no output schema, and the description partially fills that gap by enumerating the returned sections. However, with no annotations and an undocumented required parameter, an agent still lacks enough context about when to call it and what the productId must be.

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?

One parameter (productId) with 0% schema description coverage, and the description adds no meaning to it — no format, ID source, or behavior when the ID is unknown. The description's field list describes the response, not the input, so it does not compensate for the coverage gap.

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

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

States a specific verb (Get) and resource (a product's manufacturing configuration / bill of materials) and enumerates the returned contents: BOM rows, components, operations, settings. It does not differentiate itself from close siblings such as compare_product_boms, calculate_bom_requirements, or copy_product_manufacturing_config, so an agent must infer the boundary.

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

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

There is no when-to-use guidance, no statement of prerequisites, and no named alternative. The description never even mentions that a productId is required or when this lookup is preferable to get_product or compare_product_boms.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say this is a read-only lookup, what 'detailed information' actually comprises, whether related data expansion has performance cost, or what happens with an unknown customerId.

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. It is appropriately sized but so terse that it defers entirely to the name and schema.

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

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

With no annotations and no output schema, the description should compensate by describing what details are returned and how the include parameter behaves. It says nothing, leaving the agent unable to predict the response shape.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (though the 'include' description is itself thin). The tool description adds no parameter meaning at all, so the baseline 3 applies.

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

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

States a specific verb ('get') and resource ('customer') with scope implied by 'specific customer', which distinguishes it from list_customers. However it never explicitly contrasts itself with the sibling set (get_vendor, get_sales_order, etc.), so an agent gets no help beyond the name.

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 when-to-use guidance, no mention of when to prefer list_customers, and no prerequisites. Usage can only be inferred from the name and the required customerId.

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

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

With no annotations provided, the description carries the full behavioral burden, but it only states what is fetched. It does not disclose whether this is a read-only lookup, permission requirements, or whether the returned options are filtered by anything (e.g., active values).

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, appropriately sized sentence with the resource and scope front-loaded and no filler. It is efficient, though it sacrifices explanatory depth for brevity.

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

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

For a one-parameter read tool this is roughly adequate, but with no output schema the agent gets no notion of the returned option structure (labels, values, grouping by field). Given no annotations either, a little more context would materially help.

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

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

Schema description coverage is 100% with a single enumerated entityType parameter, so the schema already documents the input fully. The description's phrase 'of a specific entity type' merely echoes that, adding no format or selection semantics, so the baseline 3 applies.

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

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

The description names a specific verb (Get) and resource (dropdown options for custom fields) scoped to an entity type, so the agent understands what it returns. However, it does not distinguish this from the sibling list_custom_field_definitions, leaving the boundary between 'definitions' and 'dropdown options' to inference.

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 indication of when to use this tool versus list_custom_field_definitions or any other sibling, nor any prerequisite stated. The agent must guess the intended situation from the name alone.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses only the max-100 cap (already in the schema) and does not state whether this is a safe read, whether missing/invalid product IDs cause failures, auth requirements, or rate/partial-success behavior for a batch call.

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 compact sentence with the batch scope front-loaded and no filler. Everything stated is relevant and appropriately sized for a two-parameter getter.

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

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

For a simple read tool with full schema coverage and no output schema, the essentials are present, but the absence of annotations plus the lack of any behavioral detail (partial failure, permissions, what a 'summary' contains) leaves it only minimally 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 100%, so the schema already documents both productIds and include. The description's only parameter note ('max 100') merely repeats the schema's maxItems and the productIds description, adding no new meaning. Baseline 3 applies.

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

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

States a specific verb (Get) and resource (inventory summaries) and adds the batching scope ('multiple products at once, max 100'), which meaningfully distinguishes it from the sibling get_inventory_summary. However, it never names that singular sibling explicitly, so the differentiation is only implicit.

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 'for multiple products at once' implies when to prefer this over a single-product lookup, but there is no explicit when-to-use/when-not statement and no explicit reference to get_inventory_summary as the alternative. Usage is only inferred.

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

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

With no annotations provided, the description carries the full burden. 'Get' implies a read operation, but it says nothing about permissions, whether inactive/zero-quantity locations are included, pagination, or the shape of the quantities returned. This is a significant gap for a tool with zero 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?

A single efficient sentence that front-loads the resource and scope. It is appropriately sized, though it is so terse that it leaves obvious questions unanswered rather than being wasteful.

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

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

For a simple two-parameter read tool with full schema coverage and no output schema, this is minimally adequate. However, with no annotations and no explanation of the return shape or the meaning of 'inventory quantities' across locations, more context would help an agent confirm expected results.

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

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

Schema description coverage is 100% and both parameters (productId, include) are documented in the schema, so the baseline is 3. The description adds only 'across all locations', which scopes the result but says nothing about how the include parameter behaves (e.g., locationSummaries, sublocationSummaries).

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 ('Get') and resource ('inventory quantities') plus the scope ('for a product across all locations'), so the agent knows exactly what is returned. It does not however name or distinguish itself from the sibling get_inventory_summaries_batch, which covers similar ground.

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 single-product call versus get_inventory_summaries_batch, nor any prerequisite or exclusion. The agent must infer usage purely from the wording.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a read operation, but the description does not disclose authentication requirements, whether the response is paginated, what the 'include' parameter does, or what happens if the location is not found.

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

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

The description is a single front-loaded sentence with no filler. It is concise, though its brevity contributes to under-specification rather than 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 two-parameter tool with no output schema and no annotations, the description is incomplete. It does not explain the include parameter, the shape of the returned details, or any behavioral context an agent would need to call it correctly.

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

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

Schema description coverage is 50%: locationId is documented as 'The location ID,' but the 'include' array has no schema description. The tool description adds no parameter meaning beyond the schema and does not explain the optional include parameter at all.

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 and resource: 'Get details of a specific location.' It distinguishes a single-location lookup from the sibling list_locations implicitly through 'specific location,' though it does not name the alternative explicitly.

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

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

There is no guidance on when to use this tool versus alternatives such as list_locations or get_suggested_sublocations. The implied usage is a single-location lookup by ID, but no conditions, prerequisites, or exclusions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it says nothing beyond the word 'Get'. It doesn't disclose what happens when the ID is unknown, whether the read is safe/cached, or what the returned payload contains. A read-only implication is inferable from the verb but is never confirmed.

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 short sentence with no filler and the essential resource front-loaded. It is efficient, though its brevity edges toward under-specification rather than genuine conciseness.

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

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

For a lookup tool with no output schema, no annotations, and an undocumented 'include' parameter, the description is too thin. An agent lacks the return-shape and parameter-expansion context needed to call it confidently.

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

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

Schema coverage is only 50%: manufacturingOrderId is documented in the schema, but the 'include' array has no description anywhere. The description neither explains what 'include' expands nor how the order ID is formatted, so it fails to compensate for the coverage gap.

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

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

States a clear verb ('Get') and resource ('manufacturing order') with a scope qualifier ('a specific'). An agent can tell it fetches one order by ID, but the description does nothing to separate it from near-neighbors like list_manufacturing_orders or get_manufacturing_order_trace.

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

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

There is no when-to-use guidance at all. With siblings such as list_manufacturing_orders, get_manufacturing_order_trace, upsert_manufacturing_order, and set_manufacturing_order in the toolset, the description gives no cue about when this fetch is the right choice or what prerequisites it needs.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a diagnostic read that aggregates several data sets, but says nothing about whether it mutates anything, what 'serial anomalies' actually means, permissions required, or how large the payload may be. For a trace/diagnostic tool with zero annotation coverage this is a significant gap.

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. It is appropriately sized for its informational content, though the token list reads slightly like keyword stuffing rather than prose.

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 returns a multi-part trace with no output schema and no annotations, so the description is the only source of behavioral and parameter context. It names the data categories but explains neither the return shape nor the identifier semantics, leaving the agent under-informed for a non-trivial diagnostic call.

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 single parameter manufacturingOrderId has no description in either the schema or the description text. The description never tells the agent what identifier form to supply (internal ID, order number, etc.), which is the one piece of information a caller actually needs.

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 (trace) and enumerates the resources surfaced: output lines, input picks, pick matchings, serial anomalies. That is materially more informative than the sibling get_manufacturing_order, so differentiation is implied. It stops short of a 5 because it never explicitly names the sibling it contrasts with.

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

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

There is no when-to-use or when-not-to-use guidance. The description does not mention the related sibling reconcile_manufacturing_order_serials, nor does it say whether this is a read-only lookup or a step before reconciliation. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden. It usefully signals that default inspection is 'local' while API reachability is 'optional', hinting that only the probe path touches the network. However, it omits side effects, cost/latency, auth requirements, and what happens when the probe fails.

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 compact sentence with the core action front-loaded and no filler. It is efficient, though the abstract noun list makes the back half slightly dense for one clause.

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

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

No annotations and no output schema exist, so the description must explain both behavior and results. It has low parameter complexity (1 optional boolean), but it never describes the shape of the returned status/health information, leaving the agent unable to anticipate the response.

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 single boolean 'probeApi' is undocumented in the schema. The phrase 'optional API reachability' loosely maps to probeApi and implies it is off by default, adding some meaning, but the description never names the parameter or states the default explicitly.

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 ('Inspect') and resource ('local inFlow MCP capabilities, safety gates, and optional API reachability'). It is clearly a meta/diagnostic tool distinct from every sibling (which all operate on ERP entities), though the enumerated nouns ('capabilities', 'safety gates') are a bit abstract about what is actually returned.

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 explicit when-to-use guidance, no prerequisites, and no mention of alternatives or when NOT to call it. Use is only implied by the word 'Inspect'; an agent is left to infer that this is a preflight/health-check 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?

With no annotations, the description carries the full behavioral burden, and it does disclose one meaningful guarantee: reconciliation performs a fresh read and never repeats a write, which tells the agent the tool is non-destructive even in reconcile mode. However, it never explains what the default (non-reconcile) path returns — cached/stale status? — nor any auth or rate-limit behavior.

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

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

Two short sentences with zero waste, and the core purpose is front-loaded before the reconciliation caveat. Every sentence carries information.

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

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

With no annotations, no output schema, and 0% schema coverage on a required parameter, the description is too thin. An agent cannot tell what the status payload looks like, how to obtain operationId, or how reconcile interacts with the default read.

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

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

Schema description coverage is 0% for two parameters. The description partially compensates for 'reconcile' by explaining its effect, but says nothing about 'operationId' (required), its format, or where an agent obtains it, even though the schema only supplies a regex pattern.

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

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

States a specific verb+resource (read durable mutation status) and adds a qualifier about reconciliation semantics. It is clear enough to distinguish from generic CRUD siblings, but it does not differentiate itself from the similarly-named sibling get_mcp_status, and 'mutation' is used without defining which subsystem's mutations are in scope.

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

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

There is no guidance on when to call this tool, when to poll vs. wait, or when to set reconcile=true vs. false. The mention of what reconciliation does hints at a mode of use but never states the condition that should select it.

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

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

With no annotations provided, the description carries the full behavioral burden and falls well short: it says nothing about read-only safety, error behavior for an unknown ID, permissions, or what the returned operation type contains. Only the fact that it is a singular fetch is inferable.

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 zero filler or repetition. It is efficient, though arguably too terse to be useful rather than genuinely well-structured.

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 lookup tool with an undocumented required parameter, no annotations, and no output schema, the description is too thin. It does not explain what a 'manufacturing operation type' is, how to obtain the ID, or what the caller receives.

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

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

Schema description coverage is 0% for the one required parameter, operationTypeId, and the description never mentions it or explains its format/source. The agent must infer that the 'one' operation type is identified by an ID rather than by name or other key.

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 ('Get') and resource ('one manufacturing operation type'), so the scope (single vs. collection) is clear. However, it never names its obvious sibling list_operation_types, so the agent gets no explicit differentiation from the list variant.

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 versus list_operation_types, nor any prerequisite (e.g., needing an ID obtained from the list call). The single-retrieval shape implies usage but nothing is 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?

With no annotations, the description carries the full behavioral burden. 'Get' implies a read, and it discloses that include=itemBoms expands the payload, which is useful. It does not cover failure behavior (unknown ID), whether the include expansion is expensive, or whether results are cached/live.

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

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

Two tight sentences, scoping clause front-loaded and the include hint appended. No filler, though the second sentence duplicates a term (itemBoms) that already appears in the schema.

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

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

A simple single-resource read tool with complete schema coverage and no output schema, so return-shape explanation is unnecessary. The only real omission is routing guidance versus get_bill_of_materials, which leaves a small ambiguity among siblings.

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

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

Schema description coverage is 100%, so both parameters are already documented, including the full option list for 'include'. The description adds a definition of itemBoms only, leaving category/inventoryLines unelaborated. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb+resource ('Get detailed information about a specific product by ID'), which cleanly separates it from list_products. It also names one concrete capability (itemBoms). It stops short of explicitly disambiguating against sibling BOM tools, so it is clear but not sibling-differentiating.

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

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

Gives one useful usage hint (use include=itemBoms for the bill of materials), which is genuine when-to-use guidance for a parameter. However, siblings get_bill_of_materials and compare_product_boms exist, and the description never says when to prefer those over this tool's include flag, nor any prerequisites.

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

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

No annotations exist, so the description carries the full burden. It does disclose the read shape (a single group with its ordered options, values and variants), which is genuine behavioral context about the response. However, nothing is said about permissions, not-found behavior, or nesting depth, leaving meaningful gaps for a no-annotation tool.

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

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

A single tight sentence, front-loaded with the verb and resource and then the payload detail. No filler, though it is terse enough that the missing guidance is a function of under-specification rather than 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?

With no output schema, the description usefully names the returned components, which partly compensates. But with no annotations and zero parameter documentation, an agent still cannot tell what the ID should be or what could go wrong, so it is only minimally 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% for the single required parameter productGroupId, and the description adds nothing about its format, source, or whether it is an internal ID or a user-facing key. With only one parameter the definition should at least anchor what identifier is expected.

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?

Specific verb ('Get') plus resource ('one product group') and it enumerates the payload contents (ordered options, option values, attached product variants). It implicitly separates itself from list_product_groups (plural) and get_product_group_variant_quantities, but never names a sibling explicitly.

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

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

No when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (list_product_groups, get_product_group_variant_quantities). The agent must infer the selection rules from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation via 'Get' but does not disclose whether quantities are aggregated by location, whether missing variants are omitted or zeroed, or what permissions are needed. For a tool with zero annotation coverage this is a significant gap.

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 to scoping the operation.

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 annotations, no output schema, and 0% schema description coverage, the description is the only source of meaning and it does not explain what a 'quantity' represents (on-hand, available, committed) or the return shape. It is too thin for the information vacuum surrounding it.

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

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

Schema description coverage is 0%, so both parameters rely on name alone. The description partially compensates by mapping the concepts 'one product group' and 'one location' to the two required params, but adds no format, ID-type, or scope detail beyond that.

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

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

The description states a specific verb ('Get') and resource ('product-variant quantities') scoped to one product group and one location. An agent can distinguish this from siblings like get_product, get_product_group, or create_product_group_variants. It lacks explicit sibling differentiation, but the scoping detail makes the purpose unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives such as get_product_group, get_inventory_summary, or create_product_group_variants. The description implies a read of variant-level quantities but never states prerequisites or exclusion conditions.

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

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

No annotations are provided, so the description carries the full burden. It implies a read via 'Get', but says nothing about pagination, whether scheme names are resolved, auth requirements, or the shape of returned rows.

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 short sentence, front-loaded with the verb and resource. No filler, though the misleading pricing-scheme clause costs some 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?

No output schema, no annotations, and an undocumented required parameter. For a retrieval tool whose return values and identifier format are entirely unspecified, the description does not provide enough to call it confidently.

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

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

Schema coverage is 0% and the single required parameter productId is undocumented in both schema and description. Worse, the phrase 'pricing-scheme IDs' suggests a parameter that does not exist, adding confusion rather than clarifying productId's format.

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 verb+resource (get price rows for a product) is clear and it contrasts with the write sibling set_product_prices. However, the trailing clause 'using exact pricing-scheme IDs' describes something the schema does not support — the only input is productId — which muddies the stated purpose.

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

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

No when-to-use guidance and no named alternatives. The reader can infer it is the read counterpart to set_product_prices, but nothing states that, nor whether it should be used instead of list_pricing_schemes for price lookups.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses output semantics (serials carry stock status, and quantityOnHand=0 indicates sold/shipped), which is genuinely valuable. It says nothing about pagination on a 'get all' call, auth requirements, or result size limits, leaving those gaps.

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

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

Three short sentences, front-loaded with the core action and the key performance hint. Minor waste in the redundant 'serial numbers (serial numbers)' phrasing, but otherwise tight.

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

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

With no output schema, the description must convey return shape, and it does explain that serials come back with stock status and gives the quantityOnHand=0 interpretation. For a single-parameter read tool this is nearly sufficient; pagination behavior is the remaining omission.

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

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

Only one parameter (productId) and schema description coverage is 100%, so the schema already documents it. The description confirms the parameter is product-scoped but adds no format or sourcing detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource (get all serial numbers for a specific product) and names the underlying lookup path (inventoryLines). It implicitly separates itself from order-based siblings via 'Much faster than order-based lookup,' though it does not name them directly.

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 phrase 'for a specific product' and the comparative note about speed versus order-based lookup, which hints this is the preferred path for a single product. However, no sibling is named explicitly (e.g. get_sales_order_serials, list_all_serials) and there is no when-not guidance.

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

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

No annotations are provided, so the description carries the full disclosure burden. "Get" implies a read, but it does not state what "detailed information" includes, whether the optional include parameter triggers extra queries, or what the response looks like for a tool with no output 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?

A single efficient sentence with no filler and the key scoping qualifier front-loaded. It is appropriately sized but arguably too sparse given the undisclosed include behavior.

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

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

For a simple two-parameter read with full schema coverage and no output schema, the description is minimally adequate. It still leaves the notable include-expansion behavior and the returned detail level unexplained, which an agent would want to know before calling.

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

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

Schema description coverage is 100%, so both purchaseOrderId and the include array (with its vendor/location/lines nesting hints) are already documented in the schema. The description adds nothing about parameters, so baseline 3 applies.

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

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

States a specific verb (get) and resource (purchase order) with a scoping word ("a specific") that implicitly separates it from list_purchase_orders. However, it never names a sibling or explains how it differs from get_sales_order or get_manufacturing_order, so sibling differentiation is absent.

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 explicit guidance on when to use this versus list_purchase_orders, nor any prerequisites (e.g., that a valid purchaseOrderId must come from the list call). Usage must be inferred from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the read-only nature and return semantics ("Returns all serial numbers assigned to line items"), but says nothing about pagination, empty orders, ordering, or permissions, which is a modest gap for a simple lookup.

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

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

Two short sentences with the core action front-loaded. The parenthetical "(serial numbers)" restating the noun is minor redundancy, but nothing else wastes space.

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

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

For a single-parameter read with no output schema, the description covers what the tool does and what it returns. It is nearly complete; only the absence of any disambiguation from serial-focused siblings keeps it from being fully sufficient.

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?

One parameter with 100% schema description coverage, so the schema already documents purchaseOrderId. The description confirms it targets a specific purchase order but adds no format, example, or constraint beyond that, matching the baseline for schema-covered params.

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 ("Extract") and resource ("serial numbers from a specific purchase order") and clarifies scope as serials assigned to line items on that order. It is clear on its own, but it never differentiates itself from the many serial-related siblings (get_sales_order_serials, get_product_serials, list_serial_numbers, search_serial_number), which an agent must disambiguate against.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. An agent gets no help deciding between this and get_sales_order_serials / get_product_serials / list_serial_numbers; only the resource implied by the name distinguishes it.

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

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

With no annotations, the description carries the full burden and provides essentially none: it does not say what happens on an invalid/missing ID, whether the read is safe, what 'detailed information' comprises, or how the include expansion behaves. 'Detailed' is the only behavioral claim and it is vague.

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 efficient sentence with no filler, and the resource is front-loaded. It is arguably too terse, but nothing is wasted.

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

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

For a simple two-parameter read with full schema coverage and no output schema, the description is minimally adequate, but it omits error behavior and the semantics of the include expansion, leaving the agent to guess at return shape and failure modes.

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

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

Schema description coverage is 100%, with both salesOrderId and the include array (with dot-path examples like lines.product) documented in the schema itself. The description adds no parameter meaning beyond the schema, which is the expected baseline when coverage is this high.

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 (Get) and resource (sales order) scoped to a single record via 'specific', which implicitly separates it from list_sales_orders. However, it does not explicitly name or contrast with any sibling, so differentiation must be inferred from the name alone.

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

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

No when-to-use guidance, no prerequisites, and no mention of the obvious alternative (list_sales_orders) or how the 'include' parameter should drive usage. The agent must infer everything from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the return content ('all serial numbers assigned to line items on this order') but says nothing about permissions, pagination on large orders, or what happens when an order has no serialized line items, which matters for an unbounded list-style return.

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

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

Two short sentences with the purpose front-loaded, which is appropriate for a simple one-parameter tool. The parenthetical '(serial numbers)' immediately after the same phrase is redundant filler, costing it a perfect score.

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-read lookup with no output schema and full schema coverage, the description adequately covers what the tool returns and where the data comes from. It is only missing volume/pagination expectations for orders with many serialized line items.

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

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

Single parameter with 100% schema description coverage, so the schema already documents salesOrderId. The description only implies the parameter via 'a specific sales order' and adds no format or sourcing detail beyond the schema, making the baseline 3 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?

States a specific verb ('extract') and resource ('serial numbers') scoped to a single sales order, which implicitly separates it from the warehouse-wide siblings list_all_serials and search_serial_number. It does not explicitly name the nearest siblings (get_purchase_order_serials, get_product_serials), so differentiation is left partly to inference.

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 when-to-use guidance, no prerequisites, and never names the alternative tools (get_product_serials, get_purchase_order_serials, list_serial_numbers) an agent should compare against. The only routing signal is the 'specific sales order' scoping, which is incidental rather than stated as 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?

No annotations are provided, so the description carries the full burden. 'Get' implies a read operation, but it doesn't disclose permissions, pagination, whether it returns full or partial data, or error behavior for missing IDs. For a retrieval tool with zero annotation coverage and no output schema, this is a significant gap.

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 earns its place and the core action is immediately clear.

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

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

For a retrieval tool with no annotations, no output schema, and an undocumented optional 'include' parameter, the description is too thin. It doesn't explain what fields are returned, what 'include' does, or failure behavior, leaving an agent without enough context to invoke it confidently.

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

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

Schema coverage is 50%. The required adjustmentId parameter is documented in the schema itself ('The stock adjustment ID'), but the optional 'include' parameter has no description anywhere. The description adds no detail about what 'include' accepts or what adjustmentId format is expected, so it does not compensate for the coverage gap. Baseline 3 for partial 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?

States a specific verb+resource: 'Get details of a specific stock adjustment.' This clearly identifies a retrieval operation and distinguishes it from mutation siblings like set_stock_adjustment and upsert_stock_adjustment. It doesn't explicitly name the list sibling get_stock_adjustments, but the singular/plural naming and 'specific' qualifier make the scoping reasonably 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?

No guidance on when to use this tool versus alternatives. The sibling list includes list_stock_adjustments, set_stock_adjustment, and upsert_stock_adjustment, and the description gives no indication of when this single-record fetch is appropriate versus listing or mutating.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. 'Get' implies a read, but there is no statement about permissions, whether 'details' includes lines/locations, or error behavior for an unknown ID.

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 zero wasted words. It is efficient, though the brevity reflects under-specification rather than disciplined editing.

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 fetch tool with no output schema and one entirely undocumented parameter ('include'), the description should at minimum explain what is returned and how to expand it. As written, an agent cannot tell what 'details' means or how to shape the response.

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 only 50%: stockCountId is documented in the schema, but the 'include' array has no description anywhere and the description does not compensate. It adds no meaning about what fields are expandable or what the ID format looks like.

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 ('Get') and resource ('a specific stock count'), which is clear on its own. However, it does not distinguish itself from the sibling list_stock_counts or upsert_stock_count, so the agent must infer the singular-vs-list distinction from the name alone.

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

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

The phrase 'a specific stock count' weakly implies use when you have a single ID, but there is no explicit when-to-use guidance and no mention of list_stock_counts as the alternative for enumeration. The agent is left to infer routing from the tool name.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only retrieval ('Get details'), which is reasonable, but it doesn't disclose error behavior (e.g., what happens for an invalid ID), authorization requirements, or return shape. It's minimally adequate but not rich.

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

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

A single, clear sentence with no wasted words. It is front-loaded with the verb and resource, though it could be slightly more informative 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?

For a simple get-by-ID tool with no output schema, the description is minimally sufficient. However, it omits guidance on the 'include' parameter and behavioral context (auth, errors), leaving gaps that the description could reasonably fill given its brevity.

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 50%: 'transferId' is documented, but the optional 'include' parameter has no description in either the schema or the tool description. The description adds no meaning beyond the schema, so a baseline 3 is appropriate given partial 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?

States a specific verb ('Get') and resource ('stock transfer') scoped to a single record, which distinguishes it from the sibling list_stock_transfers. It doesn't name the sibling explicitly, but the singular 'specific' vs. list differentiation is clear from the name and description.

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

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

The word 'specific' implies retrieval by identifier, which hints at usage. However, there is no explicit when-to-use vs. when-not guidance, no mention of alternatives like list_stock_transfers, and no statement of prerequisites or 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?

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing: it never says the call is read-only, what 'suggested' is based on (existing sublocations, capacity, defaults, usage history), or whether the result is exhaustive or a heuristic ranking. The key behavioral trait of this tool is the suggestion algorithm, and it is entirely unstated.

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

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

A single front-loaded sentence with no filler, and the parenthetical gloss is the one piece of information that earns its place. It is efficient, though the terseness is part of why behavior is under-described rather than a sign of disciplined economy.

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

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

For a one-parameter lookup with no output schema and no annotations, this is close to minimally viable. The unresolved meaning of 'suggested' and the absence of any read-only/side-effect signal leave the agent guessing about what the tool actually returns.

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

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

Schema description coverage is 100% with a single required 'locationId' parameter, so the schema already documents the input and the baseline is 3. The description adds no syntax, format, or sourcing detail (e.g., where the location ID comes from) beyond what the schema provides.

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 ('Get suggested sublocations') and adds a clarifying gloss that sublocations are 'bins/shelves', which disambiguates unfamiliar domain vocabulary. It does not name or contrast against any sibling, but no sibling covers this resource, so the risk of confusion is low.

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

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

There is no when-to-use guidance, no prerequisites, and no stated alternative. The reader must infer that this is called when picking a bin/shelf for a location, and nothing explains when a static list_locations-style call would be preferable.

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

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

No annotations are provided, so the description carries the full burden. 'Get' implies a read, but there is no disclosure of permissions, error behavior for unknown IDs, or what 'detailed information' actually contains.

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 waste. It is efficient, though the brevity is partly the result of under-specification rather than disciplined editing.

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

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

With no output schema and no annotations, the agent must guess the return shape. Critically, the 'include' parameter accepts arbitrary strings but neither the schema nor the description lists valid values, so an agent cannot use it correctly.

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

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

Schema description coverage is 100%, so both parameters are documented structurally, making 3 the baseline. The description adds nothing about the 'include' array or vendorId format, but it is not required 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?

Clear verb ('Get') plus resource ('vendor') with a stated scope ('a specific vendor', i.e. single-item lookup). It reads distinctly from list_vendors and upsert_vendor, though it never explicitly names them.

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

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

No guidance on when to use this versus list_vendors or how to obtain a vendorId. The tool's role is inferable from the name but the description supplies no usage conditions or alternatives.

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

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

No annotations are provided, so the description must carry the behavioral burden. It merely says 'List all' and omits pagination behavior, read-only confirmation, authorization needs, and return shape, leaving significant gaps.

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

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

A single clear sentence with the resource and scope front-loaded. It is efficient, though the extreme brevity leaves gaps better addressed in the 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?

For a five-parameter list tool with no output schema and no annotations, the description is incomplete. It does not explain pagination, sorting, or what 'all' means in a paginated context.

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

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

Schema coverage is 60%, with descriptions for sort, sortDesc, and includeCount but not skip or count. The description adds no parameter meaning, so it fails to compensate for the uncovered parameters.

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

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

States a specific verb (List) and resource (stock adjustment reasons) with scope 'all'. It is distinguishable from list_stock_adjustments, which lists adjustments rather than reasons, though it does not explicitly name that sibling.

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 on when to use this tool versus list_stock_adjustments or get_stock_adjustment, nor any prerequisites. Usage is only implied by the tool 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?

With no annotations, the description carries the full burden, and it does disclose a real behavioral trait: the internal inventoryLines path and its speed advantage over order-based aggregation. It still omits return shape, pagination behavior, and whether large result sets are truncated, so it is helpful but incomplete for an un-annotated tool.

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

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

Three short, front-loaded sentences that get to the scope and the performance rationale immediately. Minor waste in the redundant '(serial numbers)' parenthetical following 'serial numbers'.

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?

A read-only bulk list tool with two fully documented optional params and no output schema is mostly covered, but the description never indicates what a returned record contains or how results are grouped/limited beyond maxProducts. Adequate, with a visible gap on 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?

Schema description coverage is 100% (both inStockOnly and maxProducts are documented in the schema), so the baseline is 3. The description adds no filter syntax or default behavior beyond what the schema already states.

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

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

States a specific verb (List), resource (serial numbers), and scope (across ALL products that track serials), which implicitly separates it from product-scoped or order-scoped siblings. However, it never names the closest siblings (list_serial_numbers, search_serial_number, get_product_serials), so the agent must infer the distinction.

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

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

Usage is only implied: 'Much faster than order-based aggregation' hints that this is the preferred bulk-retrieval path, but there is no explicit when-to-use/when-not guidance and no alternative tool named. The agent gets a nudge, not a routing rule.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'List all' but supports skip/count pagination and include parameters, contradicting a naive 'all' interpretation. No mention of pagination defaults, return shape, or read-only nature.

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

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

A single, front-loaded sentence with a clear verb and object. It is concise, though arguably too terse given the tool's pagination and include capabilities.

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 list tool with 6 parameters, no annotations, and no output schema, the description is inadequate. It should clarify pagination behavior, the include options, and how categories relate to sibling resources like product groups.

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 67% with 6 parameters. The description adds nothing about parameters, but the schema documents sort, include, sortDesc, and includeCount adequately. Baseline 3 is appropriate since the schema does most of the work.

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?

Clear verb+resource ('List all product categories'). It states scope as 'all', but does not differentiate from the many sibling list_* tools (list_products, list_product_groups) or clarify the distinction between categories and product groups. Still, the resource 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?

No guidance on when to use this vs alternatives. With dozens of sibling list_* tools, an agent cannot know whether categories differ from product groups. No exclusions, no prerequisites, no conditions provided.

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

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

With no annotations, the description carries the full behavioral burden, yet it only implies a read operation. It does not disclose pagination behavior, default sort order, return format, or other traits relevant to a 5-parameter list endpoint.

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 zero wasted words. It is appropriately sized for the purpose statement it provides.

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

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

For a simple read-only list tool, the description establishes the core purpose and domain. However, with no output schema and no annotations, it omits enough about pagination, sorting, and return content that an agent may need to inspect the schema to use it confidently.

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

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

The description adds no meaning for any of the five optional parameters. With only 60% schema description coverage, undocumented parameters like 'skip' and 'count' receive no explanation from the description.

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

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

The description states a specific verb ('List') and resource ('currencies') and adds scope ('configured in inFlow'). No sibling tool covers currencies, so it is unmistakable which resource this acts on.

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

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

It gives no guidance about when to use this tool versus alternatives, nor any conditions or exclusions. The intended use is obvious from 'List', but the description itself provides no routing help.

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

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

No annotations are provided, so the description carries the full behavioral burden and fails to. It is a 13-parameter read tool with no mention of pagination behavior, the max-100 cap on results, default page size, or authentication/permission needs — all of which are things an agent calling it would need before invoking.

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. It is not bloated, though one sentence is arguably too thin for a 13-parameter tool (that under-specification is captured under contextual completeness rather than conciseness).

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

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

For a tool with 13 parameters, no annotations, and no output schema, the one-line description is under-specified. It omits return shape, pagination/skip-count interaction, sorting defaults, and the meaning of 'smart' vs specific-field filters, leaving gaps that neither annotations nor an output schema fill.

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

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

Schema description coverage is 100%, so every parameter (name, skip, sort, count, smart, include, etc.) is already documented in the schema. The description adds only the generic claim of 'optional filtering', which does not extend meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('list') and resource ('customers') with the search/filter scope. However, it does nothing to distinguish itself from siblings like get_customer or the analogous list_vendors, so an agent gets no routing help beyond the name 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 phrase 'with optional filtering' only implies that filters exist; it gives no when-to-use guidance, no indication of when to prefer get_customer (single record) over this bulk list, and no exclusions or prerequisites. No alternative tools are named.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it discloses nothing beyond that it is a listing operation. It is silent on pagination behavior (skip/count), whether results are paginated or capped, default sort order, and what the definition objects contain. 'List' weakly implies a safe read, but that is the extent of the disclosure.

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

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

It is a single efficient sentence with no filler, which is good structure, but the terseness crosses into under-specification rather than genuine conciseness. Nothing is front-loaded because there is only one clause.

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

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

For a 6-parameter tool with no annotations and no output schema, the definition leaves too much unspecified: pagination semantics, default sorting, and the relationship between entityType and the returned definitions are all unstated. An agent can call it, but cannot call it confidently or correctly on first attempt.

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?

Six parameters exist with only 67% schema description coverage, and the description adds no parameter meaning at all. The undocumented 'skip' and 'count' parameters, which control pagination, are left for the agent to guess, and the description never clarifies that entityType filters the listing.

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

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

The description gives a clear verb ('List') and resource ('custom field definitions'), so an agent knows exactly what object it retrieves. It does not, however, distinguish itself from the nearby get_custom_field_dropdown_options or explain how these definitions relate to entity types. Clear but undifferentiated.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives such as get_custom_field_dropdown_options. The agent must infer usage purely from the tool name.

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

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

With no annotations, the description carries the full burden. It says 'List all' but never discloses pagination behavior, that skip/count control page size, or whether the result is capped — a notable gap for a 6-parameter listing tool. Nothing about auth, rate limits, or return shape is provided.

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 is efficient, but for a six-parameter listing tool it reads as under-specification rather than deliberate conciseness. Nothing is wasted, but very little is said.

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

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

No output schema, no annotations, six parameters, and two of them undocumented — the description would need to compensate for those gaps and does not. An agent can guess the call but cannot predict the response shape or paging 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 only 67%, and skip and count have no descriptions in the schema at all. The description adds no parameter meaning whatsoever, so the two undocumented paging parameters remain unexplained in both structured data and prose.

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

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

States a specific verb and resource ('List ... locations') and scopes it to warehouse/inventory locations, so the agent knows exactly what entity is returned. It does not, however, differentiate from siblings like get_location or get_suggested_sublocations, leaving the agent to infer the list-vs-single distinction.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no pointer to the sibling tools (get_location, get_suggested_sublocations) that an agent might otherwise pick. The agent must infer that this is the enumeration entry point from the name alone.

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

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

With no annotations, the description carries the full burden, but it only implies a read operation through the word 'list'. It says nothing about pagination via skip/count, whether includeCount is expensive, default sort order, or what is returned, all of which matter for a 12-parameter query tool.

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

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

It is a single front-loaded phrase with no wasted words, which is good structurally. However, the brevity reads as under-specification rather than disciplined conciseness given the tool's complexity.

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 12-parameter list tool with no annotations and no output schema, the description is far too thin: filtering semantics, pagination, sorting defaults, and result shape are all unaddressed. An agent could call it, but not confidently or correctly in edge cases.

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 only 50%, and six parameters (skip, count, status, include, orderDateTo, orderDateFrom) carry no schema description at all. The description adds zero parameter detail, so it fails to compensate for the coverage gap; it cannot even clarify the enum semantics of 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?

States a specific verb pair (search and list) plus the resource (manufacturing/work orders), which is clearly distinct from the singular get_manufacturing_order sibling. It does not, however, explicitly contrast itself with that sibling or explain what 'search' means versus listing.

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 when-to-use guidance is given: it never says to use this for browsing/collecting orders versus get_manufacturing_order for a single known order, nor does it describe prerequisites or pagination expectations. The agent must infer routing from the tool name alone.

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

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

No annotations provided, so the description carries the full burden. It doesn't state whether this is a read-only operation (though 'List' implies read), whether it's paginated, what fields are returned, or any rate limits. A purely descriptive sentence with no behavioral context.

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

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

Single, efficient sentence. No waste, front-loaded with the core purpose.

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

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

For a 6-parameter tool with no annotations, no output schema, and 0% schema description coverage, the description is entirely inadequate. It doesn't explain parameters, return format, or usage context. An agent would have to guess how to call this 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% with 6 parameters (skip, sort, count, isActive, sortDesc, includeCount) that are completely undocumented. The description doesn't mention any parameters or their purpose, failing to compensate for the schema gap. An agent cannot know how to use pagination, filtering, or sorting from this.

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 clear verb (List) and specific resource (manufacturing operation types). Distinguishes from sibling get_operation_type by the list-vs-get pattern, though doesn't explicitly say so. Clear enough for an agent to understand the scope.

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

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

No guidance on when to use this vs get_operation_type or other list tools. No prerequisites or context about operation types. A sibling get_operation_type exists, but the description doesn't say to use list for discovery and get for details.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about pagination behavior (skip/count exist), default result size, sort defaults, permissions, or response shape. It only restates the operation.

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 short sentence is front-loaded and waste-free, but it is under-specified rather than genuinely concise for a five-parameter listing tool.

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

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

For a 5-parameter tool with no annotations, partial schema coverage, and no output schema, the description leaves the agent without paging behavior, default limits, or result structure. It is not complete enough to call the tool confidently.

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

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

With 60% schema description coverage and five parameters, the description adds zero meaning: skip and count have no schema description either, and the description does not explain paging, sort semantics, or the includeCount flag. The schema itself is partially documented, so the description should have compensated and does not.

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

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

States a specific verb (list) and resource (payment terms), so an agent immediately knows what it returns. There is no competing sibling on this topic, so sibling differentiation is not needed, but nothing beyond the bare action is conveyed.

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 context on when to use this tool, whether pagination or sorting is expected, or how it relates to any other payment-term operation. No when-to-use or exclusion guidance at all.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about pagination defaults, permissions, or what fields a scheme contains. Apart from implying a read-only listing, it discloses no behavioral traits.

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 short sentence with no filler, front-loaded with the operation. It is efficient, though the brevity is in part under-specification rather than disciplined conciseness.

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

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

For a 5-parameter list tool with no annotations, no output schema, and two undocumented parameters, the description is far too thin. An agent gets no help on result shape, paging semantics, or typical usage.

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

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

Schema description coverage is 60%, leaving 'skip' and 'count' undocumented, and the description adds no parameter meaning at all. It neither names the paging parameters nor explains sort/includeCount behavior beyond what the schema already states.

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 clear verb+resource ('List all pricing schemes/price levels'), which is an unambiguous read operation over a specific entity. It doesn't explicitly differentiate itself from adjacent list tools such as list_taxing_schemes or list_tax_codes, but the resource noun is distinct enough.

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 on when to use this versus alternatives, nor any stated prerequisites or scope conditions. The agent must infer usage purely from the tool name.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read operation but does not disclose pagination behavior, whether results are filtered/sorted, volume expectations, or permissions. For a list tool with five parameters, this is a significant gap.

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, stating the resource and its contents first. It is efficient, though the extreme brevity is part of the underlying under-specification problem rather than excess prose.

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 five-parameter list tool with no annotations and no output schema, the description leaves pagination, sorting, and result shape entirely unexplained. It is not complete enough for an agent to call it confidently.

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

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

The schema has 0% description coverage across five parameters (skip, sort, count, sortDesc, includeCount) and the description mentions none of them. It fails to compensate for pagination/sorting semantics that an agent must know to invoke 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?

States a clear verb+resource ('List inFlow product groups') and adds what a group contains (ordered options and attached variants). It does not differentiate itself from sibling list tools such as list_products or list_categories, 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?

No guidance on when to use this versus alternatives like list_products or get_product_group, and no prerequisites or context. Usage is only implied by the verb '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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it's a read operation implicitly through 'search and list', but doesn't describe return format, pagination behavior, rate limits, or authentication requirements. For a tool with 15 parameters and no annotations, this is a significant gap.

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, efficient sentence that is front-loaded and wastes no words. It clearly states the core function without unnecessary elaboration.

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 15 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain pagination (skip/count), sorting behavior, the smart search vs individual filters, or what 'include' does. The schema provides field-level descriptions, but the description should tie these together and explain overall 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?

Schema description coverage is 100%, so the schema already documents all 15 parameters. The description adds no parameter-specific information beyond what's in the schema. Baseline 3 is correct when schema does the heavy lifting.

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?

Specifies the verb (search/list), resource (products), and source system (inFlow Inventory), which distinguishes it from get_product (single retrieval) and upsert_product (mutation). However, it doesn't explicitly differentiate itself from sibling list_* tools beyond the resources being 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?

No explicit guidance on when to use this tool versus alternatives like get_product or smart search. The description mentions 'optional filtering' but doesn't explain when to use which filter or why one would choose list vs search.

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

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

No annotations are supplied, so the description carries the full behavioral burden, and it discloses almost nothing: no default page size, no statement that results are paginated or capped (count max 100 lives only in the schema), no mention of the read-only nature, and no note on sort/filter interaction. For a 15-parameter list endpoint this is a substantial gap.

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 zero filler. It is efficient, though the terseness comes partly from under-specification rather than disciplined compression.

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?

Fifteen parameters, no annotations, and no output schema mean the description is the only place to explain paging behavior, default ordering, and what 'include' returns. None of that is present, so an agent must reverse-engineer expected behavior from the schema 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 100% with all 15 parameters documented inline, including the status enum values, sort examples, and include paths. The description adds no parameter meaning beyond the schema, so the baseline 3 applies.

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

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

Specific verb ('search and list') plus resource ('purchase orders'), which clearly separates it from get_purchase_order, upsert_purchase_order, and receive_purchase_order in the sibling list. It stops short of explicitly naming those siblings as the non-list alternatives, so it is clear but not fully differentiated.

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 'with optional filtering' hints that all filters are discretionary, but there is no statement of when to reach for this tool versus get_purchase_order (single fetch) or list_sales_orders (other resource). No prerequisites, no exclusions, no alternative routing.

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

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

No annotations are provided, so the description carries the full burden. It discloses nothing about pagination (the skip/count interplay), the hard max of 100 records in the schema, default sort behavior, whether the result is a full page or truncated, or cost/rate characteristics — all relevant for a 17-parameter query tool.

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

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

A single efficient sentence with no filler and the core action front-loaded. It is not padded, though it is arguably too terse given the tool's complexity.

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 17-parameter list tool with no annotations and no output schema, the description is insufficient: return shape, pagination semantics, and the meaning of includeCount/include interactions are left entirely to the schema. An agent can call it, but cannot predict the response or pagination behavior from the definition.

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

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

Schema description coverage is 100%, so the schema already documents every parameter (skip, sort, status enum, include nesting, date ranges). The description's 'optional filtering' adds no format or syntax detail beyond that, so the baseline 3 applies.

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

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

The description states a clear verb+resource ('Search and list sales orders') and notes that filtering is optional. It implicitly distinguishes itself from the singular sibling get_sales_order, but never names an alternative tool or scope boundary, so it stops just 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 on when to reach for this tool versus get_sales_order, upsert_sales_order, or the various list_* siblings. The only hint is the word 'optional' regarding filtering, which is not a usage condition an agent can act on.

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

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

With no annotations, the description carries the full burden, and it does disclose one important trait: the call fetches all orders and may be slow. It says nothing about permissions, pagination behavior, or result ordering, so the behavioral picture remains partial.

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

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

Three short sentences with the operation stated first and the performance warning last, so it is front-loaded and easy to scan. The parenthetical "(serial numbers)" merely repeats the noun and is dead weight.

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

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

For a simple two-optional-parameter list tool with no output schema and no annotations, the description covers the operation and a performance caveat. It omits the relationship between the 'fetches all orders' warning and the maxOrders cap, and gives no sense of the returned shape or ordering.

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

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

Schema description coverage is 100%, so both parameters (maxOrders, productId) are already documented with defaults and bounds. The description adds no syntax, format, or interaction detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (list) plus resource (serial numbers) and narrows the source to fulfilled sales orders, which implicitly separates it from siblings like list_all_serials or get_product_serials. It never names an alternative explicitly, so the differentiation is inferable rather than stated.

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

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

"Useful for building a serial number inventory" gives a use case but no when-to-use versus alternatives such as list_all_serials, get_sales_order_serials, or search_serial_number. Usage is implied rather than directed.

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

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

No annotations are provided, so the description carries the full burden. "List/search" implies a read operation, but it discloses nothing about pagination behavior (skip/count hint at paging), result limits, ordering defaults, or auth requirements. For a 12-parameter query tool this is a notable gap.

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 efficient sentence with the core purpose front-loaded and no wasted words. It is appropriately sized, though it is perhaps too terse to be maximally useful.

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 list tool with 12 params, 83% schema coverage, and no output schema, the description is minimally adequate. It omits return shape/pagination expectations that an agent would benefit from, but the rich schema compensates for most parameter-level gaps.

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

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

Schema description coverage is 83% (high), so the schema already documents nearly all parameters including enums and filters. The description adds nothing beyond "optional filtering," so the baseline 3 applies.

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

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

States a specific verb (search/list) and resource (stock adjustments), clearly distinguishing it from get_stock_adjustment and upsert_stock_adjustment by the plural/list framing. However, it doesn't explicitly name or differentiate from siblings in the text 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?

"with optional filtering" implies it's a query tool but gives no when-to-use guidance, no exclusions, and no pointer to alternatives like get_stock_adjustment for a single record. An agent must infer usage entirely.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies a read-only list operation but says nothing about pagination behavior (skip/count), default result size, or what happens when filters are omitted — all relevant for an 8-parameter query tool.

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

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

A single efficient sentence with no padding and the resource front-loaded. It is concise, though the brevity comes at the cost of the missing guidance noted in other dimensions rather than being a model of well-targeted concision.

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

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

For an 8-parameter tool with no annotations, no output schema, and 50% schema coverage, this one-line description is insufficient. An agent cannot tell how to paginate, filter, or interpret results from what is given.

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 only 50%, and the description adds no parameter meaning at all beyond the generic resource name. The undocumented parameters (skip, count, status, include) get no compensation from the description, leaving half the inputs semantically opaque.

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

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

States a specific verb ('List') and resource ('stock count/inventory count records'), clarifying the resource with a synonym. It does not, however, distinguish itself from siblings like get_stock_count or upsert_stock_count, so an agent must infer the list-vs-get-vs-write boundary from the name alone.

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

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

The description gives no when-to-use context, no guidance on the available filters (status, locationId), and no mention of alternatives such as get_stock_count for a single record. The agent gets no help deciding whether this or a sibling 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?

No annotations are provided, so the description carries the full behavioral burden and delivers almost none of it. It never states that this is a read-only operation, nor does it mention pagination behavior despite skip/count/includeCount existing, nor does it describe ordering or result shape.

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

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

A single short sentence with the resource and scoping qualified up front and no filler. It is efficient, though the brevity comes at the cost of substance rather than being purely economical.

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 12-parameter, zero-required, no-output-schema, no-annotation list tool, one sentence is insufficient. The agent is left without pagination, filtering, sorting, or safety context for an operation whose behavior is entirely undescribed.

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 12 parameters and only 58% schema description coverage, the description must compensate, but it adds nothing beyond the phrase 'between locations' loosely pointing at fromLocationId/toLocationId. Unlabeled parameters such as skip, count, include, transferDateFrom and transferDateTo remain undocumented in both schema and description.

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

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

States a specific verb pair (search/list) and resource (stock transfers), plus a scope qualifier (between locations) that tells the agent this returns transfer records. It does not explicitly differentiate itself from get_stock_transfer, upsert_stock_transfer, or set_stock_transfer, so a reader must infer the list-vs-single-vs-mutate split.

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

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

There is no when-to-use guidance: nothing says to use this for browsing/filtering transfers versus get_stock_transfer for one record or upsert/set_stock_transfer for writes. The word 'Search' loosely implies filtering, but no conditions or alternatives are stated.