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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds the crucial allowlist constraint and refusal behavior, which is not in the annotations, and clarifies GET-only, consistent with readOnly. No contradiction found.

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

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

Three short sentences that front-load the purpose and then state the constraints. No fluff; every sentence adds necessary information, making it 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?

For a single-parameter tool with no output schema, the description covers the allowed paths, the method, and the refusal behavior. It does not describe response shapes, but that is acceptable given the openWorldHint and the generic nature of an escape hatch. The information is sufficient to invoke it correctly.

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

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

The schema already provides a complete description of the path parameter (type, maxLength, example), and the tool description does not add further parameter-specific detail beyond enumerating allowed paths, which is more about usage than parameter semantics. With 100% schema coverage, 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 it is an escape hatch for read endpoints without a dedicated tool, lists the exact allowed paths, and explicitly says GET only and that anything else is refused. This clearly distinguishes it from sibling tools that handle specific read endpoints, giving an agent a precise understanding of its scope.

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

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

Explicitly states it should be used when there is no dedicated tool for the read endpoint, and restricts usage to the allowlist and GET method. It does not name sibling tools individually but the 'without a dedicated tool' condition is clear and actionable, and the sibling list is available separately.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds useful context about the returned data (variants, placements) but does not disclose any additional behavioral traits such as rate limits, authentication requirements, or response format. Since the annotations carry the main safety burden, a 3 is appropriate for the marginal added value.

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

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

The description is a single, well-structured sentence that front-loads the action and resource, then lists the key data components. Every part adds value, with no redundancy or filler. It is appropriately sized for a simple fetch operation.

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

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

Given there is no output schema, the description provides a good overview of what the tool returns (variants, blanks, sizes, colours, print placements). It does not mention error conditions or authentication, but for a read-only fetch by ID, these are less critical. The description is sufficient for an agent to understand the tool's scope and expected result.

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 only one parameter 'id' with basic type constraints, and the description does not explicitly explain that 'id' refers to the catalog product ID. Although this is implied by the tool name and resource type, the description adds no direct value over the schema. With schema coverage at 0%, the description should compensate, but it only indirectly hints at the parameter's meaning.

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

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

The description clearly states the verb 'Fetch', the resource 'Printful catalog product', and explicitly lists what is included: variants, blanks, sizes, colours, and print placements. This distinguishes it from siblings like printful_get_store_product by specifying the catalog scope, so an agent can select it correctly without ambiguity.

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 it by naming the resource type (catalog product), which contrasts with store products. However, it does not explicitly state alternatives or exclusions. The context is clear enough for an agent to infer that this is for catalog items, but it could be improved by explicitly mentioning that store-specific products should use printful_get_store_product instead.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds behavioral context about what the response includes ('in full, including line items, print files and embroidery thread options'), which goes beyond annotations. It also clarifies the exclusivity constraint between parameters. No contradictions with annotations.

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

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

The description is two sentences with zero filler. The first sentence states the purpose and scope, the second provides the parameter usage rule. All information is relevant and front-loaded. No wasted words.

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

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

For a single-order fetch with no output schema, the description gives a good sense of the return content ('in full, including line items, print files and embroidery thread options') and the required parameter handling. It does not mention error handling or edge cases, but given the simple resource and the annotations covering safety, this is adequate. It could be more explicit about the return object shape, but it is sufficiently complete.

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

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

Schema has 0% description coverage, so the description carries full responsibility for parameter meaning. It explains both parameters: printful_id is 'Printful's own id' and external_id is 'the id from the connected store, e.g. a Shopify order number.' It also states the crucial rule that exactly one must be provided. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states a specific verb ('Fetch') and resource ('one order'), and lists what is included ('line items, print files and embroidery thread options'). It distinguishes itself from printful_list_orders by focusing on a single order, and from other get tools by the specific resource. No ambiguity or tautology.

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 explicit parameter usage: 'Pass either printful_id or external_id — exactly one of them.' This is a clear rule for invocation. However, it does not explicitly name alternatives (e.g., when to use printful_list_orders instead), though the sibling list makes this inferable. It gives strong guidance on parameter selection but lacks an explicit when-not-to-use statement.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive, which covers the safety profile. The description goes beyond annotations by specifying what data is returned ('variants and the print files attached to each') and the purpose ('see which artwork a product will actually print'). This adds useful behavioral context without contradicting any annotation.

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

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

The description is two sentences with no filler. The first sentence states the core action and return content; the second provides a clear use case. Information density is high and the most important detail (fetching a single product) is front-loaded.

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

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

For a simple get-by-id tool with one parameter, a clear return description (variants and print files), and a practical use case, the description is largely complete. It doesn't detail pagination or output format, but with no output schema and annotations covering safety, this is a minor omission. The description sufficiently answers what an agent needs to know to call it correctly.

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

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

Schema description coverage is 0% and the description does not explain the 'id' parameter at all. While the parameter name is intuitive and there's only one, the description omits any explicit statement that 'id' is the sync product's ID. With zero coverage in the schema, the description should compensate by describing parameter semantics, but it does not.

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

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

The description states a specific verb ('Fetch'), resource ('sync product'), and the exact components included ('variants and the print files'). It also gives a concrete use case ('to see which artwork a product will actually print'), which clearly differentiates it from siblings like printful_get_catalog_product (catalog vs sync) and printful_list_store_products (list vs single).

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

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

The description provides a clear context for when to use the tool: 'Use this to see which artwork a product will actually print.' This implies the tool is intended for inspecting printable artwork on a specific sync product. It doesn't explicitly mention exclusions or alternatives (e.g., catalog products via printful_get_catalog_product), but the context is specific enough to guide an agent without confusion.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, covering safety and idempotency. The description adds valuable behavioral details: the 'newest first' ordering and the semantic meaning of a draft order with needs_approval true. This goes beyond what annotations provide and helps the agent correctly interpret results. It does not mention pagination details, but those are in the schema, so this is acceptable.

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

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

The description is two sentences, with the core purpose and ordering front-loaded in the first sentence, and a useful clarification in the second. There is no redundant jargon or repetition of schema details. Every sentence adds value, making it appropriately concise 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 simple list endpoint with three optional parameters and no output schema. The description covers the purpose, sorting, filtering, and a key status nuance. It does not describe pagination behavior (limit/offset) in detail, but those are standard and partially documented in the schema. For its complexity, the description is quite complete; only the offset parameter lacks any explanation, minor for this context.

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

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

Schema description coverage is 67% (limit and status have descriptions, offset does not). The description lists all status values (already in the enum) and adds the specific nuance about draft orders, which enriches the 'status' parameter meaning. However, it does not explain 'offset' at all, leaving a gap. Since the coverage threshold (80%) is not met, the description should compensate more, but it does reasonably clarify the status semantics.

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 precisely what the tool does: 'List orders for the token's store, newest first.' This specifies the verb (list), the resource (orders), and the scope (token's store). It differentiates from siblings like printful_get_order (single order) and printful_list_store_products (products) by clearly targeting orders as a collection. The sorting order and filtering capability are also mentioned, making the purpose unambiguous.

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

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

The description implies when to use the tool (to list orders) but does not explicitly contrast with alternatives like printful_get_order for fetching a specific order. It provides context on filtering by status and explains a special case (draft with needs_approval) which aids interpretation, but it does not give exclusions or explicit guidance on when to choose this over siblings. Usage is inferable but not clearly delineated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context about what sync products are (mapping storefront listing to Printful variant and print files), which is useful. However, it doesn't disclose pagination behavior, default limit, or whether the list is ordered.

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 action and resource, and includes a clarifying definition of sync products. No wasted words.

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

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

For a simple list tool with two optional pagination parameters and no output schema, the description is mostly adequate. However, it doesn't mention pagination defaults or how to navigate large result sets, and it doesn't explain what the response contains beyond the implicit product list. The sibling context helps but the description alone is slightly thin.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter meaning. The description does not mention limit or offset at all. However, the schema itself has clear names and constraints (limit integer 1-100, offset integer >=0), so an agent can infer their purpose. The description adds no extra 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 ('List') and resource ('sync products in the connected store'), and clarifies what those products are. It distinguishes from siblings like printful_get_store_product (which fetches a single product) and printful_list_orders (which lists orders), though it doesn't explicitly name them.

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

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

The description implies usage for listing sync products and explains the concept of sync products, but it does not explicitly state when to use this tool versus alternatives like printful_get_store_product or printful_get_catalog_product. No exclusions or conditions are provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral context beyond annotations by specifying that it verifies the configured token (auth check) and lists readable stores, which is useful for understanding actual operation. It does not mention failure modes or rate limits, but the added context is valuable.

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

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

Two sentences with no wasted words. The primary action is front-loaded, and the usage instruction is succinct. Every sentence earns its place: the first defines what it does, the second tells when to use it and what to extract from it.

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

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

For a zero-parameter tool with annotations already covering safety, the description is complete. It explains the output's purpose ('get a store id') and the use case (confirm connection). No output schema exists, but the description provides sufficient return-value context. Agent can call correctly without further information.

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

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

There are zero parameters, so the baseline is 4. The description reinforces the parameterless nature by focusing entirely on the tool's action. No parameter compensation is needed since schema coverage is 100% (empty schema) and there are no parameters to describe.

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+resource: 'Verify the configured token and list the Printful stores it can read.' This clearly distinguishes it from sibling tools like printful_get (generic GET) and printful_list_store_products (product listing) by focusing on connection validation and store discovery.

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

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

Provides explicit usage timing with 'Use this first to confirm the connection and to get a store id.' This gives a clear when-to-use directive, though it does not name alternative tools or explicit when-not-to-use conditions. Since it is positioned as a prerequisite step, the guidance is strong but not exhaustive.

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