Cannon Studio

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

The description discloses that it 'may update key/token usage metadata' but does not spend credits, enqueue jobs, change assets, or expose secrets. This adds behavioral context beyond the annotations, which only indicate readOnlyHint=false. The side effect is noted, though the exact nature of 'usage metadata' is somewhat vague, so a slightly lower score is warranted.

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, front-loaded with the primary purpose and directly followed by essential context about prerequisites and non-effects. Every sentence contributes value, with no fluff or repetition.

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 an output schema, the description covers the core purpose, when to use it, required authentication, side effects, and what it does not do. This is complete given the tool's simplicity and the presence of an output schema.

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

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

The tool has zero parameters, and the input schema is empty. The description correctly does not attempt to add parameter information, and the schema coverage is 100% by definition. Baseline score of 4 applies since no compensation is needed.

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

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

The description uses a specific verb ('check') and resource ('authenticated Cannon Studio account/API connectivity'), clearly stating what the tool does. It distinguishes itself from sibling tools by specifying it is for use 'before estimating or creating requests,' which sets it apart from estimation and creation tools.

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

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

The description explicitly indicates when to use the tool ('before estimating or creating requests') and states the prerequisite (OAuth or developer API key). This provides clear context and implicitly excludes use cases where authentication is not needed or where the user is already past the connectivity-check stage.

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 read-only, idempotent, and non-destructive. The description adds valuable context: no auth, no state changes, no charges, returns approved positioning, and explicitly warns agents not to invent competitor claims. This goes well beyond the annotations and helps prevent misuse.

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 concise sentences. The first states the core purpose, and the second adds key safety and operational context. No redundant wording or filler.

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

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

The tool is well-supported by a rich schema, output schema, and annotations. The description covers the essential behavioral caveat (don't invent competitor claims) and operational traits (no auth, no charges). Given the output schema exists, return format details are unnecessary, and nothing critical 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?

Both parameters have detailed descriptions in the schema, so the schema coverage is 100%. The description references 'named alternatives' and 'use case' but does not add new parameter syntax or format details. Baseline 3 is appropriate since the schema carries the parameter burden.

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

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

The description clearly states the tool compares Cannon Studio's fit against named alternatives for a use case. This is a specific verb ('compare') with a clear resource and scope, distinguishing it from sibling tools like recommend_workflow or search.

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

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

The description implies usage when a user asks for a comparison against specific competitor tools for a job-to-be-done. It does not explicitly exclude other scenarios or reference sibling tools, but the 'for a use case' phrasing provides clear context, and the caution not to invent competitor claims gives important behavioral 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?

Despite annotations indicating destructive/non-idempotent behavior, the description adds valuable context: it can spend credits up to max_credits, is irreversible after submission, and requires explicit user approval. It clarifies what it does not do, mitigating the destructiveHint's broad implication. No contradiction with annotations.

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

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

The description is three efficient sentences: purpose, requirements/risks, and workflow/exclusions. Every sentence adds value, and the most important information (explicit approval, billable, cancellation) 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 complex tool with 6 parameters, nested input objects, and an output schema, the description covers the critical operational context: approval workflow, credit limits, authentication, non-cancellation, and what it does not do. Combined with the rich schema and annotations, it is complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the meaning of 'confirmed' and 'max_credits' but does not add new parameter-level detail 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 opens with 'Create billable async Cannon Studio generation work only after explicit user approval,' which uses a specific verb (Create), resource (Cannon Studio generation request), and a clear condition. This distinguishes it from sibling tools like estimate_generation_cost or get_generation_request.

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?

Explicit workflow guidance is provided: 'Use estimate_generation_cost first, then set confirmed=true and a user-approved max_credits cap.' It also states prerequisites (OAuth or developer API key), exclusions (does not create API keys, charge payments, or delete assets), and a critical caveat that requests cannot be cancelled through MCP after submission.

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?

All annotations are false and minimally informative; the description compensates by disclosing the non-obvious side effect ('may update key/token usage metadata') and enumerating non-actions (no credit spend, no job enqueue, no asset changes). No contradiction with annotations. This goes beyond the structured data and provides meaningful behavioral context.

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

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

The description is two dense sentences with no filler. It front-loads the core purpose, then side effects and workflow; every clause carries information relevant to safe use.

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

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

The tool has nested input and output schema, but the description covers purpose, auth, side effects, and integration with two sibling tools. It does not need to explain return values because output schema exists; remaining context is sufficiently addressed.

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 is 3; the schema already documents operation examples and input shape. The description adds workflow context ('same operation/input pair') but does not add parameter-level detail beyond the schema, keeping this at the baseline.

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

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

The description opens with 'Estimate credits for a Cannon Studio generation request before creating billable work', a specific verb+resource with clear scope. It distinguishes itself from sibling tools by explicitly referencing get_api_operation and create_generation_request, showing where it fits.

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

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

It provides explicit workflow guidance: use get_api_operation first if unclear, then pass the same pair to create_generation_request after approval. It also states exclusions ('does not spend credits, enqueue jobs, or change assets') and required auth, giving clear when-to-use and when-not-to-use boundaries.

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. The description adds valuable context not present in annotations: 'no auth, no state changes, no charges' and 'Public read-only.' This informs the agent about authentication requirements and monetary implications, exceeding what the structured metadata provides.

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, front-loaded with the action, and every phrase earns its place: scope, prerequisite, safety, and alternative. There is no redundant or unnecessary wording.

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

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

Given the tool's simplicity (single parameter, output schema present, strong annotations), the description covers all needed context: when to use (after search), what it does (fetch one record), and its safety profile. The output schema documents return values, so no further explanation is needed.

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

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

The schema fully describes the only parameter 'id' as 'Record id returned by the search tool,' giving 100% coverage. The description repeats this by mentioning 'by id after search' and 'use search first,' but adds no new parameter-specific information beyond what the schema already provides. Baseline 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?

The description clearly states the action: 'Fetch one public Cannon Studio knowledge record by id after search.' It specifies the resource (knowledge record), the scoping (one public record), and the prerequisite (by id after search). It also implicitly distinguishes from the sibling 'search' tool by requiring an existing id.

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 explicit usage guidance: 'use search first when you do not already have a record id.' This directly tells the agent when to use this tool versus the search tool, making the decision clear and unambiguous.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds the context of 'no auth, no state changes, no charges,' which goes beyond annotations by covering authentication and cost implications. This useful context does not contradict annotations.

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

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

The description is a single sentence that front-loads the core purpose, then efficiently includes usage guidance and safety traits. Every phrase adds value, with no redundant or unnecessary language.

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 optional parameter, an output schema, and strong annotations, the description provides sufficient context: what the tool returns, when to use it, and its safety profile. No critical information is missing for an agent to use it correctly.

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

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

The input schema already describes the 'operation' parameter with a 100% description coverage, listing example operation IDs. The tool description does not add further parameter semantics, so a baseline of 3 is appropriate per the schema coverage rule.

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 'Return public docs for Cannon Studio developer API operations and payload shapes,' specifying both the verb and resource. It also distinguishes from siblings by naming estimate_generation_cost and create_generation_request as tools to use after consulting this one.

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 advises to 'use this before estimate_generation_cost or create_generation_request when operation/input fields are unclear,' providing a clear when-to-use context. The safety note ('no auth, no state changes, no charges') also implies it is safe to consult as a first step.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds behavioral context beyond that: 'no auth, no state changes, no charges' and 'Public read-only.' These details reassure the agent about side-effect-free operation and access requirements. 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 consists of two sentences that pack purpose, safety, and prerequisite into under 30 words. It is front-loaded with the primary function and avoids redundancy with the schema or annotations.

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

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

The tool is simple (one required parameter, read-only, output URL), and the description covers purpose, prerequisite, and safety. With an output schema present and rich annotations, no additional return-format details are needed. The combination of schema, annotations, and description fully supports correct usage.

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

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

The input schema has 100% coverage with a detailed description of product_key, including examples. The tool description adds no new semantic information about the parameter; it only refers to 'a selected offering,' which is already captured in the schema. Therefore, a baseline score 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?

The description uses a specific verb 'Return' and identifies the resource as 'the first-party Cannon Studio checkout or inquiry URL' for a selected offering, which clearly distinguishes it from sibling tools like list_offerings or get_pricing_context. The scope is explicit: it's about generating a URL, not modifying or listing.

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

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

The description explicitly instructs to use list_offerings first to get a valid product_key, providing a clear prerequisite and sequence. It also states 'Public read-only: no auth, no state changes, no charges,' which sets expectations for safe usage conditions, but it does not enumerate alternative tools or when to avoid this one.

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

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

Annotations already mark readOnlyHint=false, but the description goes further by enumerating side effects (updates lastPolledAt, syncs downstream task state, updates logs, delivers webhook) and explicitly listing what it does not do (create work, spend credits, cancel jobs, delete data, change assets). This significantly exceeds the annotation 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 three sentences, front-loaded with purpose, followed by side-effect boundaries and rate guidance. Every sentence carries essential information with no filler.

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

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

For a tool with side effects and an output schema, the description covers purpose, auth, side effects, exclusions, and polling behavior. It is complete enough for a developer to understand when and how to invoke it correctly, with only a minor gap around explicit sibling alternatives.

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 provides thorough descriptions for both parameters (request_id, include_logs), achieving 100% coverage. The description adds no additional parameter-level detail beyond mentioning poll_after_ms, which is not a schema parameter and could be slightly confusing. Baseline 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?

The description opens with 'Poll and sync an existing Cannon Studio generation request by id,' which names a specific verb (poll and sync), resource (generation request), and scope (existing by id). This clearly distinguishes it from sibling tools like create_generation_request by focusing on existing requests.

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 clear when-to-use context: for existing requests, with OAuth/API key, and advises polling sparingly with specific intervals. It does not explicitly name an alternative tool as a comparison, so it misses the full 'when-not' guidance, but the context is strong.

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

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

The description significantly exceeds annotation coverage by stating 'no auth, no state changes, no charges.' It also discloses a behavioral limitation: availability is surface-specific and does not guarantee account eligibility or remaining credits. This adds valuable context beyond the readOnly and idempotent hints.

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, information-dense sentence. Every clause adds value: the verb, resource, scope, safety guarantees, and limitation. It is well-structured and front-loaded with the core purpose.

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

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

Given the tool's simplicity (one optional parameter), strong annotations, and existing output schema, the description covers all essential aspects: what it lists, its read-only nature, auth requirements, and a key limitation. No critical information is missing for understanding how to invoke 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?

The input schema already provides a clear description for the single 'surface' parameter with examples. The tool description does not add any parameter-specific details, but because schema coverage is 100%, the description is not required to compensate. 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?

The description clearly states the tool's function: 'List public Cannon Studio model availability by product surface.' It uses a specific verb and resource, and the scope is defined. However, it does not explicitly differentiate from sibling tools like list_capabilities or list_offerings, relying on the unique term 'model availability' to imply distinction.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It mentions a surface filter and a caveat about eligibility, but does not state scenarios like 'use this before generating a request' or compare against sibling list tools. The usage context is implied rather than stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable context: 'no auth, no state changes, no charges.' This goes beyond annotations by clarifying the operational and cost implications, which is especially useful for a pricing 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?

The description is two sentences—first stating purpose, then usage guidelines and safety. Every word earns its place, and the key information is front-loaded. No filler.

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

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

For a read-only explanatory tool with a rich output schema and comprehensive annotations, the description fully covers what the tool does, when to use it, and important caveats (public, no charges). The output schema handles return details, so nothing is missing in 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 100% with each parameter clearly documented. The description does not add extra parameter semantics, but it doesn't need to since the schema carries the full load. Baseline 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?

The description clearly states a specific verb and resource: 'Explain public Cannon Studio pricing, credits, plans, and usage tradeoffs.' It distinguishes this from sibling tools by emphasizing 'public read-only' versus purchase-path tools like list_offerings and get_checkout_link.

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 explicitly instructs when to use alternatives: 'use list_offerings or get_checkout_link only when the user asks for available purchase paths.' This gives clear context and exclusions, making it easy for an agent to route correctly.

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?

Although annotations already declare readOnly/idempotent/non-destructive, the description adds key context: 'no auth, no state changes, no charges.' This goes beyond annotations by clarifying authentication requirements and cost implications, which are critical for an agent to decide whether to call the 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?

The description is two sentences that front-load the core purpose and then pack usage guidance and behavioral notes into the second sentence. Every word contributes, with no redundancy or filler.

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

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

With an output schema, return values are already defined. The description covers filters, auth/charges, and directs to search/fetch for deeper source text. It is slightly incomplete in not differentiating from similar list tools like list_offerings and list_toolkits, which is relevant given the sibling set.

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

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

The input schema already provides 100% descriptive coverage for all three parameters, with examples in each property description. The tool description only restates the filter dimensions ('audience, workflow, or output type') without adding new semantic meaning, so it meets the baseline but adds no extra 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?

The description clearly states the tool lists public Cannon Studio capabilities, with a specific verb ('list') and resource ('capabilities'). It distinguishes from search/fetch by directing deeper source-text needs elsewhere, but it does not explicitly differentiate from sibling tools like list_offerings or list_toolkits.

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 explicitly says to use search or fetch when deeper source text is needed, providing a clear when-not-to-use scenario. However, it does not mention alternatives such as list_offerings or list_toolkits, so the guidance is partial.

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?

Beyond the annotations (readOnlyHint, idempotentHint), the description adds concrete behavioral details: no auth, no state changes, no charges, and specifically that it returns first-party URLs without creating Stripe sessions or granting credits. This significantly clarifies side effects and auth requirements, exceeding what the annotations alone convey.

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

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

The description is two sentences, front-loads the primary purpose in the first sentence, and uses the second for essential behavioral constraints. Every clause adds value with no redundancy or fluff.

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

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

With an output schema present, return values are documented elsewhere. The description covers the critical context: it's a public read-only listing, no auth or side effects, and the exact behavior regarding URLs and Stripe sessions. Given the simple optional parameters and existing annotations, this is fully 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?

The input schema has 100% coverage with descriptions for all three parameters (kind, interval, include_checkout_links). The description does not add parameter-specific semantics beyond what the schema 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?

The description opens with a specific verb and resource: 'List public Cannon Studio plans, credit packs, and team offerings.' This clearly identifies the tool's function and categorizes what it returns, distinguishing it from sibling tools like list_capabilities and list_toolkits by focusing on offerings.

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

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

The description provides clear usage context: 'Public read-only: no auth, no state changes, no charges' tells the agent this is safe to call without credentials or side effects. The phrase 'without creating Stripe sessions or granting credits' implies when not to use it, contrasting with tools like get_checkout_link, though it doesn't explicitly name an 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?

The description goes beyond annotations by explicitly stating 'Public read-only: no auth, no state changes, no charges.' This adds valuable context about access control, side-effect freedom, and cost, which is highly relevant for agent decision-making. It aligns with the readOnlyHint and destructiveHint annotations without contradiction.

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

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

The description is a single, information-dense sentence that front-loads the action and resource, lists key categories, and includes crucial safety/behavioral notes. No wasted words 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?

The description is largely complete for a read-only list tool with no required parameters. It explains the purpose, routing nuances, and safety profile. However, it does not explicitly compare with sibling listing tools or describe output structure, though the presence of an output schema mitigates the latter. Overall, it covers the essential context well.

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 provides complete descriptions for all four parameters (action, family, media_type, project_context_only), and the description does not add additional parameter-level semantics. Since schema coverage is 100%, the baseline of 3 is appropriate; the description's focus is on output characteristics rather than parameter guidance.

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

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

The description clearly states the tool's function: listing specific categories of Cannon Studio toolkit surfaces (image, video, audio, etc.) and highlighting API vs. app/Director Mode routing. This specific verb+resource scope distinguishes it from sibling tools like list_capabilities and list_offerings.

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

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

The description provides clear context on what information the tool returns (which toolkits are API operations vs. app/Director Mode), which signals when to use it. However, it does not explicitly mention alternatives or when not to use it, so it misses the highest bar of explicit exclusions.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, but the description adds valuable context: 'no auth, no state changes, no charges.' This goes beyond the annotations and helps the agent understand safety and side-effect profile, especially since openWorldHint=false adds nuance. No contradiction with annotations.

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

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

Two sentences, zero waste. The first sentence states the core purpose, and the second adds safety and usage constraints. Information is front-loaded and each sentence earns its place.

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

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

Given the tool's low complexity, the presence of a full output schema, and strong annotations, the description covers all essential aspects: purpose, safety, and usage boundary. It is complete without needing to explain return values, which are handled by the output schema.

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

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

Schema description coverage is 100%, with all five parameters well-described in the schema. The description itself only mentions 'stated creative or developer goal' for the goal parameter, adding minimal extra meaning. Baseline 3 applies since 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 the specific verb 'Recommend' with the resource 'Cannon Studio workflow' and targets a 'stated creative or developer goal,' clearly distinguishing it from siblings like create_generation_request and estimate_generation_cost. It unambiguously states what the tool does.

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

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

The description explicitly states 'use this for planning, not to create generation jobs,' providing clear when-to-use and when-not-to-use guidance. It does not name specific alternative tools, but the exclusion is strong enough to guide selection. It also notes 'Public read-only' as situational context.

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

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

Annotations already indicate a safe read-only operation; the description adds 'no auth, no state changes, no charges' and explains that returned ids can be used with fetch for full text, revealing that search results may not be complete documents. This goes beyond what annotations and schema provide.

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: first states purpose and usage triggers, second discloses safety and follow-up action. No redundant phrases, highly scannable.

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

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

The description covers purpose, usage context, safety profile, and relationship to fetch, while the output schema documents return structure. This is sufficient for a read-only search tool with a rich schema.

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 five parameters are documented in the input schema. The description itself doesn't elaborate on individual parameters but does contextualize the query parameter as natural-language over public knowledge. Baseline 3 is appropriate when the schema carries the parameter detail.

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

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

Description clearly states 'Search public Cannon Studio knowledge' with a specific verb and resource. It lists common query types (products, workflows, pricing, models, comparisons, use cases, developer API docs), distinguishing it from sibling tools like fetch which retrieves full text by id.

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 specifies when to use the tool ('when a user asks about...') and explicitly directs to 'call fetch with a returned id when full source-backed text is needed', providing clear guidance on an alternative. It doesn't enumerate all sibling alternatives, but the context is sufficient.

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