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 mentions that a local file is uploaded and a quote is computed with material and print time breakdown, but it fails to disclose whether the operation is read-only, whether it creates a persistent quote record, what permissions are required, or any rate limits or side effects. This is minimal behavioral context 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?

The description is a single well-formed sentence that front-loads the action (upload) and the outcome (compute quote). There is no redundant or filler text, making it appropriately sized and easy to parse.

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

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

Given the moderate complexity, complete schema coverage, and absence of annotations or an output schema, the description is adequate but missing some contextual details. It does not clarify whether the quote is stored or ephemeral, how errors are handled, or whether any prerequisites (e.g., prior calls to list_materials) are needed. It provides basic output hints ('material and print time breakdown') but leaves gaps for an agent to 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?

The input schema has 100% coverage, so all five parameters are already documented in the schema. The description does not add any parameter-specific meaning beyond what the schema provides, such as format expectations or interdependencies. 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?

The description uses a specific verb ('compute') and resource ('manufacturing cost quote'), and explicitly states the upload of a local 3D model file with supported formats. It clearly distinguishes from siblings like list_materials or get_quality, which are lookup tools.

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

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

No when-to-use guidance is provided. The description just states what the tool does, without indicating when an agent should choose it over alternatives such as manual calculation or other quoting methods. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It does disclose two meaningful side effects beyond a bare 'cancel' — the reason is persisted and cancellation notifications are fired — which is genuinely useful. However it says nothing about required permissions, reversibility, or what happens to payments/refunds or in-progress jobs.

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 naming the action first, then its effects. No filler, though the three-clause list is slightly dense for one sentence.

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 mutation with a fully documented schema and no output schema, the description is adequate: it names the action and its side effects. It falls short on the operational context an agent would want — permission requirements, state preconditions, and refund/consequence handling — which matters more given there are zero annotations.

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% and both parameters carry descriptions with examples, so the schema does the heavy lifting. The phrase 'record the cancellation reason' implies the reason is stored rather than just logged, adding slight meaning, but nothing about format constraints or ID validation beyond the schema.

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

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

States a specific verb and resource ('Cancel an order') plus the two side effects (recording the reason, triggering notifications). It distinguishes clearly from sibling mutations like update_order and update_order_status by name, though it never explicitly contrasts 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?

There is no guidance on when to use this versus update_order_status or update_order, nor any prerequisites (e.g., only cancellable while in a certain state). The agent must infer the correct tool 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, yet it only says 'create'. It does not disclose whether titles must be unique, whether creation is idempotent, what permissions are needed, or what the call returns. For a mutation 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 wasted words, but it is arguably too terse for a creation tool and omits information rather than trimming fat.

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 mutation tool with no annotations and no output schema, the description does not say what happens after creation, whether the new template is returned or must be fetched via list_canned_responses, or how shortcut collisions are handled. It is incomplete for the complexity of the operation.

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 all three parameters (title, body, shortcut) are already documented in the schema with examples. The description adds no syntax or format detail beyond that, so the baseline of 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 specific verb and resource: create a new canned response template, scoped to the studio. An agent can distinguish it from list_canned_responses, but the description never names the sibling or clarifies the relationship, so it stops short of 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 use this tool versus list_canned_responses or send_inbox_reply, nor any note about prerequisites or when a canned response is preferable to an ad-hoc reply. Usage must be entirely inferred 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. It hints that sender data comes from stored studio settings and recipient fields can be overridden, but it omits whether this is a write operation with real-world cost, whether it is idempotent, what happens on failure, and what permissions are required.

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 verb, resource, and scoping context are all in the opening 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 mutation tool with no annotations, no output schema, and 11 parameters, the description is thin. It never indicates what the call returns (TTN number/ref), how errors surface, or the side effects of creating a live shipping document, leaving the agent under-informed before invoking 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 100% and every parameter including defaults is documented in the schema itself, so the baseline is 3. The description adds only the indirect point that unspecified values fall back to studio settings and order data, not new semantics for any individual parameter.

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

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

States a specific verb (Generate) and resource (Nova Poshta electronic waybill, TTN) scoped to an order, which is clear and concrete. However, it does not differentiate itself from the sibling print_waybill or track_shipment, so an agent must infer which of the waybill-related tools to call.

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

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

There is no when-to-use guidance, no exclusions, and no mention of prerequisites (e.g., whether the order must already exist or have a delivery address). The sibling print_waybill is left unaddressed, so routing between the two is guesswork.

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 doesn't state whether this is a mutating operation, whether it requires authentication, whether it triggers payment, whether it's reversible, or what happens on failure. Knowing it's an order submission, the agent is guessing at side effects.

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

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

One efficient sentence that front-loads the action and enumerates the payload categories without waste.

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 complex mutation tool with nested objects and no annotations or output schema, the description is missing critical behavioral context: side effects, dependencies on sibling tools (list_materials, list_qualities, get_delivery_settings), and return/confirmation behavior. It's adequate but incomplete for the tool's complexity.

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

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

Schema description coverage is 67%, so the schema documents most parameters well (filePath, materialId, printingQualityId, etc.). The description lists the parameter categories but adds no syntax or format details beyond what the schema already 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 (Submit) and resource (production order), and enumerates the key content categories (customer contact, 3D model files, materials, delivery). Clearly distinguishable from siblings like update_order or create_nova_poshta_waybill.

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 verb 'Submit' and the name, but there is no explicit guidance on when to use this vs. alternatives such as calculate_quote (quote first?) or submit_slicing_job. No when-not or prerequisites mentioned.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that results are chronological, complete, and include attachments, but it omits pagination behavior, permissions or auth requirements, and any rate-limit or read-only confirmation.

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

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

The description is a single, front-loaded sentence that states the action and returned data with no wasted words. It is efficiently structured for a simple retrieval 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 one-parameter getter with no output schema, the description adequately identifies what is returned: a complete chronological message history and attachments. Minor gaps like pagination or result limits are not covered, but the core retrieval behavior is clear.

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 single conversationId parameter is already fully documented in the schema. The description does not add any parameter-level meaning, making the baseline score of 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?

The description states a specific verb (retrieve) and resources (complete chronological message history and attachments) for a customer conversation. It is clear on its own, but it does not explicitly distinguish itself from sibling tools such as list_inbox_threads.

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

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

The description provides no when-to-use guidance, no when-not-to-use guidance, and no alternatives or prerequisites. The intended usage is only implied by the tool name and the phrase 'for a customer conversation'.

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 the returned data (lifetime value, order history, status breakdown), which is useful, but it doesn't state whether the operation is read-only, whether it requires permissions, or what happens for a nonexistent customer. For a read operation with one ID, this is adequate but not rich.

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

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

A single, front-loaded sentence that lists the key returned data with no filler. Every phrase earns its place by naming a distinct component of the profile.

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 one simple parameter, full schema coverage, and no output schema, the description adequately conveys what the tool returns and when to call it. It could be stronger if it noted authentication or error behavior, but for this complexity level it is nearly complete.

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

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

Schema coverage is 100% and there is a single required parameter documented with type and constraints. The description adds nothing about the parameter, but with complete schema documentation the baseline is 3; a 4 is warranted because the parameter is simple and fully specified in the schema, and the description correctly implies a single-customer lookup.

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

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

The description states a specific verb (Retrieve) and resource (customer profile) and enumerates the data returned: lifetime value, order status breakdown, order history. It is clear what the tool does, though it doesn't explicitly differentiate from sibling 'list_customers', which is a minor gap for a read tool with only one required ID parameter.

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 you use this to get a single customer's full profile (given the required customerId), but it does not state when to use this versus list_customers or get_order_details, nor does it mention authorization or exclusions. Usage is inferable from the name and parameter, but not explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It clearly implies a read-only retrieval operation from the wording 'Retrieve current...configuration,' which gives the agent reasonable confidence this is a safe, non-mutating call. However, it doesn't disclose auth requirements, whether the config is cached, or error behavior if shipping isn't configured.

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 colon-delimited sentence that front-loads the verb and resource, then lists the returned fields. Every clause earns its place; there's no filler or redundancy.

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

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

For a zero-param, no-output-schema read tool, the description does well by enumerating the returned configuration fields, effectively standing in for a missing output schema. It stops short of stating auth needs or listing all field values (e.g., what shipping methods exist), but it's complete enough for correct invocation.

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

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

The tool takes zero parameters, so per the rules the baseline is 4. The schema is empty and the description correctly conveys that this is a parameterless call by describing a fixed-scope configuration retrieval, adding no misleading parameter hints.

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 (Retrieve) and specific resource (studio delivery configuration), then enumerates exactly what's included: Nova Poshta sender branch, pickup address, enabled shipping methods. An agent can immediately distinguish this read-only config lookup from siblings like get_studio_info or list_orders.

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

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

The description implies usage — you'd call this when you need shipping/delivery configuration — but it never explicitly states when to use this versus alternatives like get_studio_info, nor does it mention any prerequisites or exclusions. Usage context is inferable but not spelled out.

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 shape of the returned data (flat-rate and percentage pricing formulas), which is useful. It says nothing about behavior on an unknown/invalid ID, whether the operation is read-only, or any permission requirements — gaps 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?

One front-loaded sentence with zero filler; the verb and resource lead and the key qualifier ('by ID') closes it. Nothing is repeated from the title or schema.

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

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

For a single-parameter lookup with no output schema, the description tells the agent both what entity is fetched and what data it returns (flat-rate and percentage formulas). The remaining gap is behavioral — error handling and where the ID originates — rather than a missing core concept.

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 the single id parameter is already documented as a positive integer unique ID, so the baseline is 3. The phrase 'by ID' adds no format, range, or sourcing detail beyond what the schema 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 (Retrieve) and resource (flat-rate and percentage pricing formulas for a post-processing finishing operation) with an explicit lookup key (by ID). This cleanly separates it from the sibling list_finishings, which enumerates rather than fetches one. An agent can select it without opening the schema.

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

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

Usage is implied rather than stated: 'by ID' signals that an identifier is required, which in practice comes from list_finishings. However, the description never names that sibling, gives no when-to-use/when-not-to-use conditions, and states no prerequisites. Adequate but with clear gaps.

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

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

No annotations are provided, so the description carries the burden. 'Retrieve' implies a safe read, and 'full details' hints at the response scope, but it says nothing about error behavior for unknown IDs, required permissions, or rate limits. Adequate but thin 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?

One sentence, front-loaded with the verb and resource, zero padding. Nothing to trim.

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

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

For a single-parameter read tool with no output schema and no annotations, the definition covers the basics but does not explain what 'full details' includes or how an agent should obtain a valid ID. A brief pointer to list_materials would close the gap.

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

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

Schema description coverage is 100% and the single id parameter is fully documented (unique numeric ID, exclusiveMinimum 0). The description only echoes 'numeric ID', adding no format or sourcing detail beyond the schema.

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

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

States a specific verb ('Retrieve'), resource ('3D printing material'), and lookup key ('numeric ID'), which cleanly distinguishes it from the sibling list_materials and get_* variants. It does not, however, explicitly route the agent to list_materials for discovering IDs, 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?

Usage is implied: fetch one material when you have its ID. There is no explicit when-to-use vs list_materials, no note that an ID must be obtained first, and no exclusions. Minimum viable for a simple lookup.

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 full behavioral burden. 'Retrieve' implies a read-only lookup with no mutation, and the description discloses the returned data composition. It does not mention authentication requirements, error behavior, rate limits, or whether missing orders return empty versus error responses, leaving some behavioral gaps.

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

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

The description is a single front-loaded sentence that efficiently communicates the action, key identifier, and returned data. Every phrase earns its place.

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

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

With no output schema and no annotations, the description supplies the main return-value context by listing the manifest components. For a single-parameter lookup tool, this is largely complete, though it could mention error or permission 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 single orderId parameter is already clearly documented by the schema. The description adds 'by ID' but no additional syntax, format, or constraint details beyond what the schema already 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?

The description states a specific verb (Retrieve) and resource (complete order manifest by ID), then enumerates the key data returned: customer profile, ordered parts, slicing files, and shipping tracking. This clearly distinguishes it from sibling tools like list_orders, update_order, and cancel_order.

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 'by ID' implies the tool should be used when an order ID is known, which is useful context. However, it does not explicitly state when to use this tool versus alternatives such as list_orders or update_order, nor does it mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses the content categories returned (hardware, maintenance, queue), which is genuinely useful and implies a read-only operation, but says nothing about permissions, failure modes for an invalid/nonexistent ID, or rate limits.

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

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

One front-loaded sentence with the verb and resource first and no filler; every clause adds scope information.

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

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

For a single-parameter getter with no output schema, the description usefully enumerates the returned data categories, partially compensating for the missing output schema. It is nearly complete, missing only edge-case and error 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 coverage is 100% and the single 'id' parameter is already documented as 'Unique numeric ID of the printer'. The description only restates 'by ID' and adds no format, range, or lookup semantics beyond the schema.

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

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

States a specific verb (Retrieve) and resource (3D printer) plus the scope of data returned (hardware details, maintenance schedule, print queue). 'by ID' implicitly distinguishes it from the sibling list_printers, but it never names 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?

Usage is only implied: an agent infers it should call this when it already has a printer ID and needs one printer's details rather than the list. No when-not conditions, prerequisites, or sibling alternatives 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?

With no annotations provided, the description carries the full behavioral burden. It does disclose the returned content (specs, photos, lead time), which is useful, but says nothing about read-only safety, permission requirements, or behavior on a nonexistent 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 naming the action, resource, and payload with zero filler. Nothing is wasted and the key scope (specific ID) leads the intent.

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 100% schema coverage and no output schema, the description usefully compensates by naming the returned fields. The only gap is error/miss behavior, which is minor for a read-only getter.

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% with a single well-documented 'id' parameter (integer, positive). The description's 'by ID' adds no syntax or format detail beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

States a specific verb (Retrieve) and resource (product) and enumerates what comes back — specifications, media photos, and turnaround lead time. The phrase 'a specific product by ID' implicitly distinguishes it from the sibling list_products, though it never names that 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?

Usage is implied by the singular 'a specific product by ID' versus the list_products sibling, so an agent can infer it is the single-item lookup. However, there is no explicit when-to-use statement, no mention of what to do if the ID is unknown, and no named alternative.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Retrieve' implies a read, but the description says nothing about permissions, whether an unknown ID errors, or the safety profile of the call. For a zero-annotation tool this is a thin 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?

A single front-loaded sentence with the verb and resource first and the returned data appended; nothing is wasted. It could be marginally tighter but is 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 simple one-parameter getter with a fully documented schema and no output schema, the description is nearly sufficient — it even sketches the return contents. The only gap is silence on failure/permission 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% for the single 'id' parameter, which the schema already describes as the unique numeric ID. The description's 'by ID' phrasing adds no format or range detail beyond the schema, so the baseline of 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 specific verb ('Retrieve') and resource ('printing quality profile') and even names the fields returned (slicing parameters, layer height). The 'by ID' qualifier implicitly separates it from the sibling list_qualities, though it never names an 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 when-to-use guidance, no mention of prerequisites (e.g. obtaining an ID from list_qualities), and no exclusions. The retrieval context can only be inferred from the get_/list_ sibling naming pattern.

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 full behavioral burden. It says 'async' and 'check progress', but doesn't state whether the job can expire, whether results are cached, how often to poll, or what happens on failure. This is insufficient for a tool that likely interacts with a long-running process.

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

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

The description is a single, front-loaded sentence that states the action, object, and a hint of return values. It is efficient and contains no waste. A 4 rather than 5 because it could be slightly more structured or scannable, but it's well-sized for 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 status-check tool with no annotations and no output schema, the description is sparse. It doesn't explain return format, possible status values, error conditions, or polling behavior. The mention of 'print duration and filament weight metrics' hints at output but doesn't fully cover the tool's behavior. Significant gaps remain.

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 fully documents the single required parameter 'jobId'. The description mentions 'by ID' but adds no further syntax, format, or constraints. 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?

The description states a clear verb+resource: 'Check progress of an async 3D slicing job by ID'. It also mentions return metrics. It doesn't explicitly differentiate from siblings like submit_slicing_job or calculate_quote, but the ID reference implies usage after job submission. Still, without naming alternatives, it falls 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?

The description implies when to use this tool (after submitting an async slicing job) but doesn't explicitly state when to use it versus alternatives. No conditions, exclusions, or mentions of sibling tools are provided. This is adequate but lacks explicit 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 supplied, so the description carries the full burden. It does disclose that the response includes credential-adjacent data (API key details), which is meaningful behavioral context an agent should know before calling, but it says nothing about whether the key is masked, what happens on auth failure, or any rate limits.

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

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

A single sentence with no filler, and the verb-plus-resource core is front-loaded. Every word earns its place.

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

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

With no output schema and no annotations, the description compensates by enumerating the returned fields (identity, studio ID, API key details). That is adequate for a zero-parameter read, though it omits failure behavior and whether the API key value is exposed or truncated.

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

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

The tool takes zero parameters, and the schema is empty, so there is nothing for the description to clarify. Baseline 4 applies for a parameterless tool.

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 pairs a specific verb ("Retrieve") with a specific resource (studio identity, studio ID, and API key details), leaving no doubt what the call returns. It implicitly separates itself from the sibling get_studio_stats by promising identity/credential data rather than metrics, but it never names that sibling, so it falls 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 statement of when to call this versus alternatives, no prerequisites, and no mention of the nearest sibling get_studio_stats. The word "authenticated" hints the tool is for verifying the current session, but that is inference rather than 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 behavioral burden. 'Retrieve' implies a read and 'real-time' discloses data freshness, which is useful. However, it says nothing about permissions, rate limits, or how expensive the aggregation is, leaving meaningful behavioral 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 dense sentence that front-loads the verb and packs the return categories efficiently. There is no filler or redundant restatement of the name.

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

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

With no output schema and no annotations, enumerating the four returned metric categories is genuinely valuable and compensates well for the missing output schema. It falls short only on the behavioral and usage dimensions rather than on describing what the tool yields.

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 the single enum parameter is fully documented with options and the default in the schema. The description adds only the phrase 'for a given period,' which adds no syntax or 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?

The description states a specific verb ('Retrieve') and enumerates the exact resources returned: financial metrics, order-status breakdown, printer fleet load, and top materials. This rich enumeration makes it clearly distinguishable from siblings like list_orders or get_studio_info in practice, though it never names an 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 aggregate-stats tool versus get_studio_info or the many list_* tools it overlaps with conceptually. The period framing implies a reporting use case, but no alternative, prerequisite, or exclusion 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?

No annotations are provided, so the description carries the full burden. It does disclose the shape of the returned data (contact details, item counts, recovery links), which is genuinely useful context for a read operation, but it says nothing about permissions, whether the data is sensitive/PII, or pagination behavior beyond the schema.

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

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

A single front-loaded sentence with zero filler that conveys purpose and return content at once.

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 list tool with no output schema, the description usefully previews the returned fields, which compensates for the missing output schema. Only the absence of any read-only/permission framing keeps it short of 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?

Both parameters (page, limit) are fully documented in the schema at 100% coverage, so the baseline is 3. The description adds no pagination or filtering semantics 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?

Specific verb+resource: 'List unfinished 3D print quote checkouts,' with concrete scope (customer contact details, item counts, recovery links). It is clearly distinguishable from generic siblings like list_orders, but it never explicitly contrasts itself with the nearby review_abandoned_quote tool.

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

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

The mention of 'recovery links' implies the abandoned-cart recovery use case, so intended usage can be inferred. However, there is no explicit when-to-use guidance and no mention of the related review_abandoned_quote alternative, leaving the agent to guess.

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 disclosure burden, but the verb 'List' reliably signals a read-only, non-destructive operation. It discloses nothing about pagination, ordering, or result volume, which are minor for a simple template listing but remain unstated.

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

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

A single compact sentence with no wasted words, front-loading the verb and resource immediately. Nothing extraneous and nothing buried.

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

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

For a zero-parameter, read-only list tool with no output schema to explain, the description is sufficient to call it correctly. It only lacks minor detail such as whether results are paginated or ordered.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There are no parameter semantics to add or omit.

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

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

States a specific verb ('List') and resource ('preconfigured studio quick-reply templates'), which clearly distinguishes it from siblings like create_canned_response and list_inbox_threads. However, it does not explicitly name or contrast with any sibling tool, which would be required for 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 when-to-use guidance, no prerequisites, and no alternatives named. The phrase 'for customer communications' hints at context but does not tell an agent when to choose this over, say, list_inbox_threads or create_canned_response.

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. 'List' implies a safe read, but the description says nothing about pagination behavior, sort order, rate limits, or result size caps beyond what the schema already declares.

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 dense sentence with no filler; the core resource and returned data are front-loaded. It could be slightly tighter, 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 read-only list tool with no annotations and no output schema, the description usefully previews returned fields (order counts, total spent) and the search dimension, which is adequate. It omits any framing of pagination defaults and how it relates to the customer-profile sibling, leaving minor 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 100%, so the schema already documents page, limit, and search fields in detail. The description's 'search by name or phone' is actually narrower than the schema (which also covers email), 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?

Specific verb 'List' plus resource 'studio customer directory' plus the returned fields (lifetime order counts, total spent) and search capability. Clear what it does, but it does not distinguish itself from the sibling get_customer_profile, which an agent could confuse it 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?

The description never states when to use this listing tool versus the per-customer get_customer_profile, nor any prerequisites. Usage is only implied by the verb 'List' and no alternatives or exclusions 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?

No annotations are supplied, so the description carries the full burden. It does disclose that pricing is included in the response, which is useful return-value context, but says nothing about auth requirements, pagination, or whether the catalog is studio-scoped. For a simple read-only list this is adequate but not rich.

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

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

One sentence, front-loaded with the verb and resource, and the parenthetical examples earn their place by clarifying the domain. Slightly dense but no wasted framing.

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, so the description must hint at returns — and it does via 'with pricing', the most salient field. For a zero-required-param list tool with a fully documented filter, this is nearly complete; only return shape/pagination detail is missing.

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

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

The single 'technology' filter has 100% schema description coverage with an example enum-style list ('fdm', 'sla', 'sls'), so the schema does the heavy lifting. The description never mentions filtering at all, so it adds nothing beyond the schema — baseline 3 is correct.

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 (finishing services) and enumerates concrete examples (vapor smoothing, painting, support removal, sanding) plus the 'with pricing' payload. It is clearly distinguishable from the singular get_finishing sibling, though it never names that 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?

Usage is only implied — an agent can infer this is the browse/discovery call for finishing options before drilling into get_finishing. There is no explicit when-to-use, when-not-to-use, or named alternative, so it falls at the 'implied usage' level.

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 almost nothing beyond the one-liner. It does not state whether results are paginated, what a thread record contains, or any ordering/limit behavior. The word 'active' is ambiguous since the schema permits filtering by non-active statuses.

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 action verb leading. It is appropriately sized, though its brevity reflects under-specification rather than genuine 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 list tool with four optional parameters, no output schema, and no annotations, the description omits what is returned, how pagination behaves, and default ordering. An agent lacks enough to call it correctly beyond guessing at the filters.

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

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

Schema description coverage is 100%, so the baseline would normally be 3, but the description actively enumerates only three channels ('Telegram, Instagram, and web portal') while the channel enum also supports 'email'. This omission risks making an agent believe email threads are unsupported, so it subtracts rather than adds value.

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

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

States a specific verb ('List') and resource ('studio customer support conversations' / inbox threads), making the operation instantly recognizable. It does not differentiate itself from siblings like get_conversation_messages or send_inbox_reply, so it falls 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?

The description gives no guidance on when to use this versus alternatives. It never mentions get_conversation_messages (for reading a thread's contents) or send_inbox_reply (for responding), nor any prerequisite or exclusion, leaving the agent to 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 burden. 'List all' implies a read operation, but the description doesn't state permissions needed, pagination behavior, whether results are cached, or sorting order. For a list 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?

Single sentence, no waste, front-loaded with the core action. Slightly packed but effective.

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?

Adequate for a simple list tool with 3 optional params and 100% schema coverage, but with no annotations and no output schema, the description doesn't cover behavioral aspects like pagination or return format. Missing prerequisites or usage context that would help an agent call correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description mentions color, technology, and stock status as returned fields and the schema documents the corresponding filters, but the description adds no syntax or format details (e.g., color matching is case-insensitive substring, technology codes like 'fdm') beyond what the schema already 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 (list) and resource (materials), and specifies scope and returned fields (filaments, resins with pricing, color, technology, stock status). Clearly distinguishable from the sibling 'get_material' (single item) and unrelated list_* tools.

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

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

Implied usage from the name and description — it lists all materials, with filterability via the schema parameters. However, there's no explicit guidance on when to use this vs. 'get_material' for a single item, or when not to use 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 behavioral burden. It implies a read/list operation but never states it is non-mutating, and says nothing about default result volume, sort order, or empty-result behavior. This is a meaningful 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 with the resource front-loaded and the filter facets trailing, so nothing is wasted. It is arguably too terse given the gaps elsewhere, but the sentence itself 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 list tool with a fully documented schema and no output schema, the description is minimally adequate. However, with no annotations, it leaves the read-only nature and result-volume expectations unexplained, which slightly under-delivers for an agent deciding how to call it.

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

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

Schema description coverage is 100%, so the schema already documents page, limit, search, and the status enum in full. The description only restates the same filter categories without adding syntax, format, or matching semantics 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+resource ('List studio production orders') plus the filtering capabilities, which is clear. It does not explicitly differentiate from siblings like get_order_details or get_studio_stats, but the resource is distinct enough that an agent won't confuse it. Solid but not sibling-aware.

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 or when-not-to-use guidance is given. The description says what can be filtered but never indicates the context that should trigger this tool over get_order_details or list_abandoned_quotes. The 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 burden. It discloses the return payload (technology, model, build volume, maintenance notes, active queue), which is useful, but says nothing about pagination, auth requirements, or that this is a non-mutating read beyond what 'List' implies.

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

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

A single front-loaded sentence with no waste, and the field enumeration is load-bearing given the absence of an output schema. It could be marginally tighter but nothing is padded.

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-param read tool with no output schema, the summary of returned fields is important and present. The gaps (pagination behavior and a pointer to the filter parameters) are minor against the low complexity of the operation.

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 optional filters (status, technology) are documented with examples in the schema, establishing a baseline of 3. The description adds nothing about these filters, so it neither compensates nor extends the schema.

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

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

States a specific verb (List) and resource (3D printers in the studio fleet), and enumerates the fields returned. Scope ('all ... in the studio fleet') implicitly distinguishes it from the singular get_printer sibling, though it never names that 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?

Usage is only implied: 'List all' signals bulk retrieval vs the singular get_printer, but there is no explicit when-to-use/when-not guidance. The description also ignores the available status/technology filters, so an agent must infer when to narrow the query.

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 hints at return contents (fixed pricing, photos, lead time) and implies read-only behavior via 'List', but never states pagination, ordering, permission needs, or whether inactive products appear by default.

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 front-loaded sentence with no filler. The trailing attribute list (pricing, photos, lead time) is marginally useful but slightly dilutes the core action.

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

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

For a zero-required-parameter read tool with no output schema, an agent can invoke it, and the description gives a rough sense of returned fields. Missing are any hint of result volume/pagination and the default filtering behavior, which matter even for a simple list 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 100% and the single activeOnly parameter is fully documented in the schema, so the baseline of 3 applies. The description adds nothing about the filter, notably what the default (omitted) behavior is.

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 (catalog products) with scope narrowed to products 'manufactured by the studio'. However, it does not distinguish itself from the sibling get_product or explain what separates a catalog product from related resources like materials or qualities.

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 exclusions, and no mention of alternatives such as get_product for a single product. The description reads as a passive inventory summary rather than a routing instruction for an agent choosing among ~35 siblings.

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

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

Annotations are absent, so the description must carry the full behavioral burden and does not: it never states this is a read-only operation, says nothing about pagination, ordering, or result size, and gives no hint of the return shape beyond naming a few fields.

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

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

A single front-loaded sentence with no filler; the parenthetical field list is dense but earns its place by telling the agent what a 'quality' record actually contains.

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, the description plus schema cover the essentials: what is listed, what fields it holds, and how to filter. Only return-format and pagination details are missing, which are minor here.

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?

Both parameters are fully documented in the schema (activeOnly, technology with example codes), so the schema does the heavy lifting. The description adds no filtering behavior or default semantics beyond what the schema already 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 (List) and resource (3D printing qualities and slicing profiles) and enumerates the fields those records carry. It is clearly separable from get_quality and list_materials by name, though it never explicitly says so.

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 singular get_quality sibling for fetching one profile. The parenthetical content list implies what you get back but not when to reach for this 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 burden. It does disclose the return content (status, version, latency) and its read-only, non-mutating nature is evident, but it says nothing about authentication requirements, timeouts, or failure behavior when the Placraftic API is unreachable.

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 that leads with the action and enumerates the outputs; no filler or redundancy.

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

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

For a zero-parameter health-check with no output schema and no annotations, the description adequately conveys what the call does and roughly what it returns. Additional detail on failure modes or latency thresholds would round it out, but nothing essential is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify beyond what the schema provides; the baseline for a no-param tool 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 ('Check') and three concrete resources: server status, version, and server-to-API latency. Nothing else in the sibling list performs this diagnostic, so an agent can identify its role immediately.

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

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

Usage is only implied by the nature of a ping/diagnostics call; there is no statement of when to reach for it (e.g., before retrying a failed request, on connection errors) or when it is unnecessary.

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 usefully clarifies that the tool returns a document *link* rather than the PDF itself, but it says nothing about what happens when the order has no generated waybill, whether the link expires, auth requirements, or rate limits.

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

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

A single front-loaded sentence that names the verb, the resource, and the output format without any filler or redundancy.

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

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

For a one-parameter read tool with no output schema, the description is adequate: it explains what the returned link is for. However, the lack of any precondition or failure-mode information leaves behavioral gaps that annotations would otherwise have covered.

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

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

Schema description coverage is 100%, so the orderId parameter (type, exclusivity, meaning) is already fully documented in the schema. The description adds no parameter-level detail beyond what the schema provides, so the baseline of 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 ('official printable Nova Poshta PDF document link for shipping labels and package stickers'), which is concrete and distinguishable from the write-oriented sibling create_nova_poshta_waybill. It does not explicitly name that sibling, but the read-vs-create distinction is inferable from the wording.

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: an agent can infer this is called after a waybill exists to obtain its print link, reinforced by the schema's 'order with a generated waybill' note. There is no explicit when-to-use statement, no mention of alternatives like create_nova_poshta_waybill, and no stated precondition for calling 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 disclosure burden. It does reveal the observable consequence of the mutation (avoiding duplicate customer contact) and the status it sets, but says nothing about permissions/auth, reversibility, idempotency, or the response, which matters for a write 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 front-loaded sentence that states the action first and the rationale second, with no wasted words. It is terse rather than padded; only the slight redundancy of "acknowledge followup" trims it from a 5.

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, no-output-schema tool this is close to complete on the 'what', but as an unannotated mutation it omits what state the quote must be in and what the agent gets back, leaving minor gaps an agent might need 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 coverage is 100% and the sole quoteId parameter is already documented as the lead's numeric identifier, so the description adds no parameter meaning 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?

The description pairs a specific verb ("Mark... as reviewed/reminded") with a specific resource ("abandoned quote lead"), and the goal clause distinguishes it from the adjacent list_abandoned_quotes sibling. The only fuzzy point is the dual state "reviewed/reminded," which leaves the exact state transition slightly ambiguous.

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 an implied purpose ("acknowledge followup and avoid duplicate customer contact"), which suggests why an agent would call it, but no explicit when-to-use condition, no prerequisites, and no reference to siblings like list_abandoned_quotes for locating a lead to review.

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 never says this dispatches an irreversible message to a real customer, whether retries duplicate sends, what permissions/credentials are needed, or what a failure looks like. The only behavioral hint is the optional template fallback, which the schema already conveys.

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 action and target front-loaded and no filler. It is efficient, though it is arguably too terse for a mutation tool that reaches an external customer.

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?

Four parameters at full schema coverage keep the structured side complete, but with no annotations and no output schema the description should say more about delivery semantics, error/return behavior, and the message-vs-template precedence. It is adequate but leaves real gaps for a customer-facing send operation.

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 is already documented in the schema, including the message/templateId conditional. The description adds nothing new about parameter meaning or formats, making the baseline 3 the right level.

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 ('Send') and resource ('outbound message ... directly to the customer') and names the delivery channels (Telegram, Instagram), which no sibling tool provides. An agent can distinguish this send action from read-side siblings like list_inbox_threads or get_conversation_messages without opening the schema.

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

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

Usage is only implied by the 'reply' framing against a conversation; there is no explicit when-to-use statement and no guidance on when to prefer a plain message vs a template, nor any mention of prerequisites or alternatives. The alternative of creating a canned response first (create_canned_response sibling) is never referenced.

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 disclosure burden. It usefully reveals the async nature of the operation (returns a job ID rather than a result), that the file is read from the local filesystem, and which formats are accepted, but it says nothing about failure modes, permissions, prerequisites for printingQualityId, or the job lifecycle.

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 packs verb, resource, accepted formats, and return type with no filler whatsoever.

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

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

No output schema exists, but the description compensates by stating the return value is an async job ID, and the schema fully covers inputs. The remaining gap is the absence of guidance on retrieving results via the paired get_slicing_status tool.

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

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

Schema description coverage is 100%, so both parameters are already fully documented in the schema, making 3 the baseline. The description restates the format list (dropping .stp) and the local-file nature of filePath, adding only marginal meaning beyond the schema.

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

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

The description states a specific verb and resource ('Submit a local 3D model file... to cloud slicer') and enumerates supported formats, so the agent knows exactly what the tool does. It does not, however, name the sibling it pairs with (get_slicing_status), so it falls short of full sibling differentiation.

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

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

Usage is implied by the description's mention of obtaining an 'async slicing job ID', which suggests a follow-up poll, but the description never states when to use this tool versus alternatives or that get_slicing_status is the way to retrieve results. No explicit when/when-not guidance is present.

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 usefully discloses the external dependency (Nova Poshta) and implies a sync/fetch against that provider, but says nothing about whether it mutates local order state, what happens for an unknown order ID, error behavior, or any auth/rate constraints.

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 with the action and the source system front-loaded and no filler. It is efficient, though the compression comes at the cost of the missing guidance noted 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 one-parameter, non-nested tool with no output schema, the description states the input key, the data source, and the shape of what is returned (checkpoints plus delivery status), which is what an agent needs to call it correctly. The only real gap is the undocumented sync/mutation 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% and the single parameter is fully documented in the schema, so the baseline is 3. The description's 'by order ID' adds no syntax, format, or edge-case detail beyond the schema's 'Unique numeric ID of the shipped order'.

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 concrete verb pair ('Synchronize and retrieve') plus a specific resource ('live parcel checkpoints and delivery status') scoped to a named provider and input key ('from Nova Poshta by order ID'). It is clearly distinguishable from generic order tools, though it never explicitly contrasts itself with the nearest siblings such as get_order_details or create_nova_poshta_waybill.

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 and no named alternative. An agent cannot tell from the text whether to reach for this versus get_order_details, print_waybill, or create_nova_poshta_waybill for a given delivery question.

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 for a mutation tool. It says only that details can be updated; it does not disclose required permissions, whether changes are reversible, what happens to existing values, or whether any side effects occur. Naming the updatable fields is useful but falls well short of full behavioral disclosure.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for the task, though the hedge 'such as' slightly weakens precision about the full field set. Still efficient and 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?

The tool is a mutation with no annotations and no output schema, so the description must cover behavior and usage. It omits permissions, side effects, and when to prefer it over siblings like update_order_status or cancel_order. For a write operation, this leaves meaningful 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 100%, so the schema already documents orderId, totalPrice, and customerNotes thoroughly. The description adds only examples of two fields and does not clarify format, validation, or required status beyond what the schema provides. 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?

The description states a clear verb (update) and resource (order details) and names two updatable fields, total price and customer notes. It implicitly distinguishes itself from update_order_status by focusing on order fields rather than status, though it does not explicitly call out that sibling. Clear enough to identify the tool's scope without opening the schema.

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

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

There is no guidance on when to use this tool, when not to, or which alternatives exist. The sibling set includes update_order_status, cancel_order, and create_order, but the description never routes the agent among them. It states what can be changed but not the conditions or prerequisites for doing so.

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 hints at a side effect worth knowing ('dispatch studio timeline events'), but does not say whether transitions are validated (e.g. cancelled -> pending), whether notifications fire, whether the change is reversible, or what represents failure. The one side-effect note is useful but insufficient.

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 verb and object lead. It is compact, though the 'dispatch studio timeline events' clause is somewhat jargon-heavy and unattributed.

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 mutation tool with no annotations and no output schema, so the description must explain validation, side effects, and error behavior. It mentions an event dispatch but omits transition rules, notification recipients, and return/error semantics, leaving it under-specified for a state-changing operation.

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 the status enum and comment/orderId fully documented inline, so the baseline is 3. The phrase 'Kanban stage' loosely maps to the status enum but adds no syntax or constraint detail beyond the schema.

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

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

States a specific verb+resource: 'Transition an order to a new Kanban stage'. An agent can tell this is a status-change operation, not a general field update. However, it never distinguishes itself from the sibling 'update_order', leaving the boundary between the two 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 guidance on when to use this tool versus update_order, cancel_order, or a bulk order edit. No prerequisites, allowed source states, or exclusions are stated, so the agent must guess the appropriate context.

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