sella

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

Annotations already declare readOnlyHint=true; the description reinforces this with 'Read-only.' It lists the specific data returned, adding behavioral context beyond the annotations.

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

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

The description is a single sentence with no wasted words. It front-loads the core purpose ('Your spending headroom') and lists details compactly.

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

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

Given zero parameters and no output schema, the description provides a thorough list of returned fields (limits, amounts, caps, thresholds, etc.), making the tool's functionality fully understandable.

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 no parameters, so schema coverage is 100%. Description does not need to add parameter info baseline is 4.

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 what the tool returns: spending headroom with detailed budget components (daily/monthly limits, amounts, caps, thresholds, etc.). It uses specific verbs and distinctively describes the functionality 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 usage context (checking budget status) and explicitly marks it as read-only. While it does not provide alternatives or when-not-to-use, the uniqueness among sibling tools makes it sufficiently clear.

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 readOnlyHint annotation already declares the tool is read-only. The description adds behavioral context by detailing what gets compared (price, quality, trust, etc.), but does not cover error handling or auth requirements. Given the annotation, no contradiction and useful extra detail.

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 with zero waste. It front-loads the purpose and follows with usage guidance. Every sentence adds value.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, scope, and usage timing. It lacks detail on return format or error cases, but is sufficient for an agent to decide when and 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 only parameter, listing_ids, is already fully described in the schema with 100% coverage. The description does not add new meaning beyond the schema, so 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 clearly states the tool's purpose: 'Side-by-side comparison of 2 to 6 listings' and lists specific comparison dimensions (price, quality, trust, etc.). It distinguishes itself from siblings by specifying it is for comparing candidates after search_catalog.

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 tells when to use the tool: 'Use after search_catalog to choose between candidates.' It does not specify when not to use or alternatives, but the context is clear enough.

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 annotations (destructiveHint: true), the description adds that the tool requires an x402 payment signature covering $10 USDC and returns a Job ID. It omits details like irreversibility or side effects, but the payment and progress tracking info 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?

Three well-front-loaded sentences with no extraneous words. Each sentence provides essential information: the action, the return value, and the critical requirement.

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

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

Given the complexity (triggering a remote process with payment) and no output schema, the description adequately covers the return value and payment requirement. However, it lacks details on default base model behavior or potential errors.

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 3. The description adds extra context for the payment_signature parameter (covering $10 USDC for compute), which goes beyond the schema definition. Other parameters are not elaborated, but this addition lifts the score.

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 triggers a Cradle Father-Agent to breed a child AI model on RunPod, returning a Job ID. This verb-resource pairing is specific and distinguishes it from siblings like get_job or merge_models.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies it's for creating a child model, but does not mention prerequisites, when not to use it, or suggest sibling tools like get_job for tracking progress.

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 adds 'Free, read-only, briefly cached,' which goes beyond the readOnlyHint annotation by mentioning cost and caching behavior. It fully discloses the tool's non-destructive, safe operation and data freshness.

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 slightly verbose but front-loads the main purpose. Every sentence adds value, and the structure is logical. Could be slightly more concise, but still 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?

Given no output schema, the description thoroughly enumerates the data returned (product kinds with counts, price ranges, categories, taxonomy, filters, sorts). It also covers usage timing, cost, and caching, making it fully informative for an agent.

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

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

The input schema has zero parameters, so no parameter documentation is needed. The description compensates by explaining the rich output content, which is critical given no output schema exists.

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 provides catalog orientation including product kinds, counts, price ranges, categories, API taxonomy, and search filters. It directly distinguishes from the sibling tool 'search_catalog' by indicating it should be called once before searching.

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 'Call once before searching if you do not know the catalogue,' giving a clear condition for use. However, it does not explicitly state when not to use it or name alternatives, but the context and sibling list imply it's a one-time setup tool.

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

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

Annotations declare readOnlyHint=true, and the description reinforces read-only behavior with 'fetch'. It adds transparency by detailing the output structure, though it omits potential error cases or side effects (which seem minimal).

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 filler. The first sentence enumerates return fields efficiently; the second provides motivation. Every word serves a 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 no output schema, the description adequately covers what the tool returns. It could include mention of possible errors or optional pagination, but for a simple fetch-by-ID tool, it is largely 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% with a description for receipt_id. The description adds value by contextualizing the parameter's source (purchase_preview or purchase response), going beyond the schema's basic description.

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

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

The description clearly states the tool fetches a decision receipt by ID, listing specific return fields (verdict, reasons, policy version, price, spend snapshot). It conveys a specific verb-resource pair and distinguishes from siblings like purchase_preview by focusing on audit retrieval.

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 context via 'audit answer' and specifies that input comes from purchase_preview or purchase response. However, it does not explicitly contrast with alternatives like policy_check or offer when-not-to-use guidance.

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

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

Annotations declare readOnlyHint=true, and the description adds that authentication is required. It also lists the specific data categories included, which provides context beyond the annotation. However, it does not mention pagination, rate limits, or data freshness, which would further enhance transparency.

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

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

Two sentences: the first enumerates the tool's outputs, the second gives a clear use case. No wasted words, and the most important information (what the tool does) 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?

The description lists the types of activities returned but does not describe the output structure (e.g., JSON fields, pagination, or how sections are organized). Without an output schema, more detail on the return format would be helpful for effective usage.

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

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

Schema coverage is 100% with a single optional 'limit' parameter that already has a clear description and default. The tool description adds no additional meaning to the parameter, so the 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 clearly enumerates the specific account activities returned (spend summary, receipts, likes, reviews, flags, disputes, jobs) and explicitly states the use case: to re-find previously purchased listings before buying again. This distinguishes it from sibling tools like get_listing or search_catalog.

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 states the tool requires authentication and provides a concrete scenario ('re-find previously purchased listings before buying again'). While it does not explicitly list when not to use it or compare to alternatives, the use case is clear enough for an agent to decide.

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?

Adds significant context beyond the read-only annotation: states single-use, lists possible statuses (pending, approved, denied, expired, consumed), and describes completion flow.

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 sentences, front-loaded with main function, no redundant information.

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

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

Covers dual mode, states, and consumption. Without output schema, return format is implied but not explicit, which is acceptable.

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%, but description adds source of the ID and behavioral nuance (polling vs listing). Enriches parameter 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?

Clearly states it checks an escalated purchase approval, with two distinct modes: polling by ID or listing without. Distinguishes from siblings by describing a specific purchase approval lifecycle.

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 describes when to use each mode and the post-approval action. Lacks explicit exclusions or comparisons with sibling tools.

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

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

Annotations have readOnlyHint=false, which may contradict the retrieval purpose, but the description adds detail about the payment flow and return of instructions. It does not cover error handling, response format, or other behavioral traits beyond payment.

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 packs the main purpose and payment requirement. It could be split for clarity, but it is efficient and front-loaded with 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?

With 4 parameters, a payment dependency, and no output schema, the description is too sparse. It does not explain the full payment flow, error states, or what 'instructions' mean, leaving the agent underinformed 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?

Schema coverage is 100%, so the schema adequately describes each parameter. The description adds no new information beyond what is in the schema (e.g., mentions PAYMENT-SIGNATURE but schema already explains it). 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 clearly states 'Retrieve full dataset content,' which is a specific verb+resource combination. It distinguishes this tool from siblings like list_datasets or search_datasets by explicitly indicating it retrieves the full content.

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 mentions payment requirements for paid tiers, giving some context on when to provide payment parameters. However, it does not explicitly state when not to use this tool or offer alternatives for summary views (e.g., describe_catalog).

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 provide readOnlyHint=true, and the description adds value by detailing the returned fields, the auto-credit behavior for failed paid runs, and job visibility scope. No contradiction.

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

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

Three concise sentences front-load the purpose and returns, then add behavioral notes on refunds and visibility. 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 no output schema, the description sufficiently explains the tool's return fields and side effects (auto-credit). Given the simple single-parameter read-only operation, 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?

Only one parameter (job_id) with 100% schema coverage; the schema already describes its source (from cradle_breed_agent or merge_models). The description does not add further semantic details.

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 (poll), the resource (Cradle or Merge job), and the key returned fields (status, result, error, refund state). It distinguishes from sibling tools like cradle_breed_agent and merge_models that create jobs.

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 mentions polling a Cradle or Merge job, which implies usage after those creation tools. However, it does not provide explicit when-not or alternative tools, though the context is clear.

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 the description adds behavioral details beyond that: it explains the return structure (common evidence, kind-specific detail, pay quote) and the identifier formats for different listing kinds (hex for datasets, slug for APIs, specific product names). No contradictions.

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 the core purpose, and packs detailed information about what each kind includes without unnecessary words. Every 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 complexity (multiple listing kinds, multiple detail sections), the description covers the main points: what is returned for different kinds, the pay quote inclusion, and the free status. It is sufficient for an agent to understand the tool's utility, though it omits potential error scenarios or rate limits, which are minor given 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%, so parameters are already well-documented. The description adds extra context by explaining the meaning of listing_id for different kinds (24-character hex, provider slug, product names), which is not in the schema. This provides additional semantic clarity.

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 retrieves full pre-buy detail for one listing by id, specifying what it includes (common evidence card, kind-specific detail, pay quote). It distinguishes from sibling tools like get_dataset or search_catalog by being a comprehensive pre-buy view.

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

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

The description implies the tool is for pre-buy details, especially when you have a listing id and need a comprehensive view before purchase. It also mentions it's free, providing context. No explicit when-not or alternatives, but the purpose is clear enough.

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 provide readOnlyHint=true; description adds deprecation status and future removal, which is valuable behavioral context beyond 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 concise sentences front-loading the deprecation warning. Efficient, though no structured breakdown.

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 deprecated tool: addresses deprecation and return fields. However, with no output schema and 9 parameters, more parameter context would improve completeness.

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?

Nine parameters exist with 56% schema description coverage, but the description provides no additional meaning for any parameter. It only mentions return fields, leaving parameter semantics to 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?

Clearly states the tool lists datasets and specifies return fields (titles, descriptions, etc.). It also distinguishes from sibling tool search_catalog by noting deprecation and directing to the alternative.

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

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

Explicitly states the tool is deprecated and advises to search_catalog (kind=dataset) instead, providing clear when-to-use guidance and 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 adds behavioral context beyond the readOnlyHint annotation: it states the tool is deprecated and that the response shape is kept for one release. This informs the agent about the tool's lifecycle and compatibility.

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, front-loaded with deprecation warning and core purpose. No wasted words, efficient and clear.

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

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

Given full schema, readOnly annotation, and no output schema, the description is complete: it covers deprecation, scope, filters, and result limits. No missing information for invocation.

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

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

Schema coverage is 100%, so the description does not need to add parameter details. It notes 'optional filters' and 'use limit' but these are already clear from the schema. No additional semantic value provided.

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

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

The description clearly states the tool's function: searching the Sella Data Market catalogue with filters. It also explicitly distinguishes from sibling tool 'search_catalog' by indicating deprecation in favor of that 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 description provides explicit guidance: 'Deprecated: prefer search_catalog (kind=api)' and mentions that results are bounded, advising to use 'limit'. This clearly indicates when to use this tool versus alternatives.

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

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

Annotations already mark this tool as destructive (destructiveHint: true). The description adds that it triggers a service and requires payment, which aligns with destructive behavior but does not elaborate further on side effects or irreversible actions.

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

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

The description is extremely concise with three sentences, each conveying essential information: action, output, and prerequisite. No unnecessary 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?

Given the tool's complexity (triggers compute, requires payment), the description covers the main points. It mentions returning a Job ID for tracking but does not explain how to use it, though sibling tools like get_job exist. Slight gap could be filled, but overall adequate.

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 adds context about payment for the payment_signature parameter but does not add significant meaning beyond the schema descriptions for both parameters.

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

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

The description clearly states the specific verb 'Triggers' and resource 'Sella Merge service to fuse AI models using a Mergekit configuration.' It also mentions the output (Job ID). No sibling tool performs merging, so it is well-differentiated.

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

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

The description mentions a prerequisite (x402 payment signature covering $15 USDC) but does not explicitly state when to use this tool versus alternatives, nor does it provide guidance on 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?

Annotations declare readOnlyHint: true, and the description reinforces this by stating no receipt or approval is created and it is a dry-run. The description adds context about the return value including verdict and reasons, but the safety profile is already clear from 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 concise at two sentences, with the purpose front-loaded. Every sentence adds essential information without 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?

Despite lacking an output schema, the description explicitly states the return values: verdict (allow, deny, or escalate), reasons, and current spend. It also notes that no creation occurs, making the tool's behavior fully specified for an agent.

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

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

The schema has 100% description coverage, and the description adds valuable context by explaining the mutually exclusive usage: listing_id vs. amount_usdc (with optional kind). This clarifies the intended semantics beyond the schema's individual 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 it performs a dry-run policy check on a purchase before committing, returning a verdict with reasons and current spend. The verb 'dry-run' and resource 'policy against a purchase' are specific, and the description distinguishes it from other tools by emphasizing it does not create any receipt or approval.

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 advises using this tool before committing to avoid denials at payment time. It outlines two usage modes: checking a specific listing via listing_id, or checking a hypothetical spend via amount_usdc and optional kind. It does not explicitly state when not to use it, but the guidance is clear.

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 provide readOnlyHint=true, and the description confirms a read operation with 'Read the purchasing policy'. It adds detailed behavioral context by enumerating the exact fields (spend caps, limits, escalation threshold, etc.), helping the agent understand what the tool returns without requiring an output schema.

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

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

The description is a single comprehensive sentence listing many fields, which is efficient but slightly dense. It front-loads the core purpose and includes necessary detail without fluff. A minor improvement would be breaking into two sentences for readability, but it remains concise.

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 zero parameters and no output schema, the description fully specifies what the tool returns by listing all relevant policy fields. It also explains the relevance ('Discovery and purchases are governed by this policy'), providing complete context for an agent to understand the tool's output and purpose.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to add parameter meaning since none exist, and the schema is trivially complete. No additional parameter context is required or provided.

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 'Read the purchasing policy in force for your account', specifying the verb (Read) and resource (purchasing policy). It lists the specific fields included, distinguishing it from sibling tools like policy_set (write) and policy_check (verify). The name 'policy_get' reinforces the get semantics.

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 one needs to view the current policy, stating that 'Discovery and purchases are governed by this policy.' However, it does not explicitly contrast with alternatives or specify when not to use it, leaving selection guidance implicit.

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

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

Annotations declare the tool is neither readonly nor destructive. The description appropriately adds that it performs a partial update, that tightening limits have immediate effect, and that commerceMode=human_assisted requires operator approval. No contradictions with annotations. However, it omits potential side effects like triggering notifications or requiring authorization.

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 concise with three sentences, each serving a clear purpose: purpose and partial update, immediate effect, and specific parameter behavior. No wasted words, but could be more scannable with bullet points or subheadings for a tool with 11 parameters.

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

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

Given the tool's complexity (11 parameters) and lack of output schema, the description covers key behavioral aspects but does not explain the effect of many parameters (e.g., temporalStart, requiredFields, spend limit interactions). Adequate but leaves gaps for an AI agent to fill via schema alone.

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

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

Schema description coverage is high (73%), so the schema already explains most parameters. The description adds useful context for 'commerceMode' and the general behavior of tightening limits, but does not elaborate on other parameters like 'agentType' or spend limits. Baseline 3 is appropriate given coverage.

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

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

The description clearly states 'Update the purchasing policy for your account', which is a specific verb-resource pair. It also adds the partial-update detail ('Only the fields you pass change; the rest are unchanged'), distinguishing it from a full replacement. The name 'policy_set' aligns with this purpose and contrasts with sibling tools like 'policy_get'.

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 context (e.g., 'Tightening limits takes effect immediately...' and 'commerceMode=human_assisted...'), but it does not explicitly state when to use this tool versus alternatives like 'policy_get' for viewing or 'policy_check' for validation. Usage is implied rather than clearly guided.

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 indicate it is not read-only and not destructive. The description adds that it emits a decision receipt without settling, and mentions operator approval requirement. 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?

Two sentences: first explains the tool's function and outputs, second provides usage guidance. No extraneous information, efficient and front-loaded.

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

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

Despite no output schema, the description lists all key return elements (price, fees, decision, receipt_id, approval_id). It covers the tool's purpose and behavior adequately for a preview tool with one parameter.

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

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

The only parameter, listing_id, is already well-described in the input schema (100% coverage). The main description adds no additional semantics beyond what the schema provides.

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

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

The description clearly states the tool provides a quote and policy verdict for a listing before purchase, including specific outputs like price, fees, decision, receipt_id, and approval_id. It distinguishes itself from siblings by instructing to call it before get_dataset or paid 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?

Explicitly tells when to use the tool: 'Call this before get_dataset or a paid tool to commit to a decision.' It also implies it's a preview without settling, providing clear context for appropriate usage.

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

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

Annotations only show readOnlyHint=true. Description adds behavioral context: ranked results, per-item reasons, seed logic based on category/tags/agents, and no-seed behavior based on recent usage. No contradictions.

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, front-loaded with core function, concise explanation of modes, and explicit exclusion. No redundant or unnecessary 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?

All three optional parameters are explained. Both usage modes are covered. Output format (ranked with reasons) is mentioned. Distinguishes from search. No output schema 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?

Schema coverage is 100% with clear parameter descriptions. Description adds overall context but does not significantly enhance meaning beyond schema for individual parameters.

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

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

Description clearly states the tool returns ranked related listings with per-item reasons, specifying two modes (seed-based and no-seed). It uses specific verbs and resource, and distinguishes from sibling tool search_catalog.

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 guidance on when to use with a seed listing vs. without (authenticated). Explicitly states not a keyword search and directs to search_catalog as 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 discloses that the tool is free, returns ranked listings with quality evidence, facet counts, and a page cursor. Annotations declare readOnlyHint=true, and the description aligns with a read-only search operation, adding context about default behavior and separate open_model kind 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 four sentences, front-loaded with the core purpose, and each sentence delivers essential information: scope, parameter usage, output, safety, and guidance. No redundant or vague statements.

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 18 parameters, no required ones, and no output schema, the description adequately covers overall behavior and key parameters. It references describe_catalog for further taxonomy details. Missing explicit mention of default output format or error handling, but overall sufficient.

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

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

With 94% schema coverage, the description still adds value by explaining the kind parameter's default and separate open_model behavior, and noting that common shorthands are expanded for the query parameter. This enhances understanding beyond the schema's individual 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 the tool performs a single search across the Sella marketplace, covering multiple product kinds including curated datasets, APIs, workflows, native products, and open models. It distinguishes from sibling tools like search_datasets and search_open_models by being the unified entry point.

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 advises using this tool when the task is known but the product kind is not, then refining with kind and filters. It mentions that the tool is free to call and directs to describe_catalog for taxonomy. However, it does not explicitly state when not to use it or list alternatives for exclusive searches.

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?

Discloses that it returns a legacy flat-array response, has the same ranking as search_catalog, and is kept for only one release. This adds context beyond the readOnlyHint annotation, including future removal.

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 concise sentences: deprecation/alternative, general purpose, specific advice. No wasted words, front-loaded with critical 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?

The description covers deprecation, response format, and a key use case, but lacks details on the full response structure and other nuanced behaviors. Acceptable for a deprecated 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 coverage is 56%; the schema itself provides descriptions for most parameters. The description only adds meaning for required_fields, not for the other eight parameters. Adequate but leaves gaps.

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 searches the catalogue by keyword and optional filters, notes it is deprecated, and directs to search_catalog. It also highlights a specific use case for required_fields, 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?

Explicitly advises to prefer search_catalog (kind=dataset) and warns about the legacy flat-array response and limited lifespan. Also provides a specific scenario for using required_fields to check schema before payment.

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 is transparent beyond the readOnlyHint annotation, explaining that Sella does not host or run inference, that results are ranked with details like license and popularity, and that links are provided to both Hugging Bay and the original source. No contradictions.

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?

Four sentences, each earning its place: first states purpose, second announces free/no-wallet, third describes return data, fourth gives usage guidance and limitation. No fluff, well 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 tool with two simple parameters and no output schema, the description covers purpose, return content, and limitations adequately. It lacks explicit comparison to sibling search tools but is otherwise complete.

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

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

Schema coverage is 100%, so the description adds limited value. The query parameter gets example values but no new semantic context, and the limit parameter is not elaborated beyond what the schema 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 tool searches an open-source AI catalogue, listing specific types (open-weight LLMs, image/audio/video models, datasets) and powered by Hugging Bay. However, it does not differentiate from sibling search tools like search_catalog or search_datasets, leaving ambiguity about when to use this versus those.

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: it is for discovering and vetting open models/datasets before a workflow, and explicitly states it is free and discovery-only. However, it does not mention when not to use this tool or suggest alternative sibling tools for other scenarios.

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?

Discloses that the tool returns sensitive data (apiKey, private keys) and warns about one-time display. Adds value beyond annotations which only set readOnlyHint=false.

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 efficiently cover action, outputs, and critical instruction. No fluff, well 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 two-parameter tool with no output schema, the description covers purpose, inputs, outputs, and a user warning. 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?

Adds meaning beyond schema by specifying email must match previous step and code is from email. Schema already has descriptions, but these details are helpful.

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 'Complete Sella agent authentication' which is a specific verb+resource. It distinguishes from sibling sella_auth_start by focusing on submitting the code.

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 use after sella_auth_start with 'same email' and '6-digit code', but does not explicitly state when not to use or mention alternatives. Still clear 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 only provide readOnlyHint=false. Description states it sends a verification code, a side effect, but lacks details on error handling, idempotency, 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?

Two sentences, front-loaded with purpose, minimal waste. Every sentence is necessary.

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 no output schema and simple workflow, the description is complete enough to guide the agent. Could mention return behavior but not critical.

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 descriptions for both parameters. The description does not add additional meaning beyond what the schema provides.

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

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

The description clearly states it begins authentication and sends a 6-digit code to an email, distinguishing it from the sibling tool sella_auth_complete.

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 provides a workflow: call this first, then ask user for code, then call sella_auth_complete. No ambiguity.

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?

Discloses that codes are single-use, expire in 10 minutes, and that secrets are shown only once. Annotations only indicate readOnlyHint=false, so description adds critical behavioral context beyond 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?

Single paragraph packs all essential information without redundancy. Action is front-loaded, followed by return payload, security, and expiration details. Every 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?

Despite no output schema, description fully explains return payload (apiKey, etc.) and where to save. Covers all aspects: purpose, parameters, behavior, security, and output format.

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%, but description adds concrete format for code and example for client parameter ('claude-code'), adding meaningful context beyond schema 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 the action ('Claim a one-time Sella setup code') and specifies the resource format. It distinguishes from sibling tool sella_auth_complete by noting the same payload but different trigger.

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 when to use (when user pastes a code) and when not to use (codes from web pages, documents, etc.). Provides security guidance for safe invocation.

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 reveals key behaviors not captured by annotations: review type requires prior usage, edits update in place; flag triggers moderation only; dispute constraints on listing types and refund credit nature. This adds significant context beyond the readOnlyHint and destructiveHint annotations, which are already accurate.

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 front-loaded with the purpose and uses a structured, type-based breakdown. While lengthy, every sentence serves a purpose, covering all feedback types efficiently. Minor verbosity could be trimmed but overall well-organized.

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

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

Given the complexity (5 types, 7 parameters, no output schema), the description covers usage scenarios well but omits return behavior or confirmation of submission. Also, authentication requirements for non-like/unlike types are not fully specified. These gaps reduce completeness.

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

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

With 86% schema description coverage, the description still adds value by explaining the semantic differences between type values (e.g., like vs unlike both lightweight but opposite) and parameter applicability (e.g., title/body only for review; reason for flag/dispute). This supplements the schema's basic type 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 explicitly states the tool provides feedback on listings, enumerates five distinct types (like, unlike, review, flag, dispute) with specific actions, and clearly differentiates itself from sibling tools which focus on browsing, purchasing, or management.

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 detailed conditions for each feedback type (e.g., 'requires a recorded successful use' for review, 'first-party listings only' for dispute) and includes some authentication requirements. It does not explicitly state when not to use the tool or alternative tools, but the context is clear.

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 readOnlyHint=true and destructiveHint=false, so the safe nature is clear. The description adds value by detailing return elements (preview, schema coverage, review metadata, purchase guidance) and confirms no full content is returned. No contradictions.

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 deprecation and alternative, second functionality. No unnecessary words; all information is front-loaded and essential.

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 trial tool without output schema, the description covers return items adequately. Annotations cover safety. Missing error conditions or pre-purchase state, but given simplicity and sibling context, it is reasonably 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 covers both parameters with descriptions (dataset_id: 'The dataset ID to trial'; required_fields: 'Optional fields to verify before purchase'). The description adds trial context and clarifies 'required_fields' purpose beyond the schema, so it adds 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 clearly states the tool's purpose: inspect a dataset in a trial environment before purchase, returning preview content and purchase guidance. It distinguishes itself by mentioning 'prefer get_listing' for a pay quote, making the domain specific.

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 it is deprecated and to prefer 'get_listing', providing a clear alternative. It also specifies the use case: before purchase, and clarifies what it does not return (full paid content).

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