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

The description adds useful behavioral context beyond annotations: it reveals that results are incremental (only since the last check) and that there is rate-limit etiquette ('One polite request per search'). This complements the annotations, which only flag non-read-only, non-idempotent behavior. It doesn't explicitly disclose whether the check advances the last-check timestamp, but the incremental semantics strongly imply state tracking.

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 compact and front-loaded, with the core behavior stated first. Each of the three sentences earns its place: main action, scheduling/etiquette context, and single-search usage. There is no filler or redundancy with the schema.

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

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

For a tool with one optional parameter and a present output schema, the description covers the essential operational contract: what it does, what it returns (new listings), how to limit scope, and the appropriate usage pattern (scheduled agent). The output format is presumably defined by the existing output schema, so no return-value details are missing. Nothing an agent needs to decide when to use this tool is omitted.

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

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

The schema already fully documents the sole optional parameter with the description 'Check just this saved search; omit to check all.' The main description repeats this idea ('Pass name to check a single search'), but adds no new semantic detail about name format or behavior when omitted. With 100% schema coverage, a baseline of 3 is appropriate and the description does not meaningfully enhance parameter understanding.

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 re-runs saved searches and reports only new listings since the last check, which is a specific verb+resource pairing. This distinguishes it from siblings like list_saved_searches or save_search, which merely list or create searches. The scope of output is also precise: only newly appeared listings.

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 explicitly frames the tool as 'ideal for a scheduled agent,' giving a concrete usage context. It also explains the single-search use case with 'Pass name to check a single search.' However, it does not mention when not to use it or name alternative tools for different needs, so it lacks 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?

The description adds a substantive behavioral trait beyond the annotations: one polite request per listing not in the 30-min detail cache, indicating rate limiting and caching. The readOnlyHint=false and openWorldHint=true annotations are consistent with the idea of making external requests, though the description doesn't detail authentication or additional side effects.

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

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

Two compact sentences lead with the action and result, then add the key behavioral caveat. Every sentence earns its place with no redundant phrasing.

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 is complete: it states what is checked, what is reported, the request policy, and the intended scheduled-agent context. Nothing critical for invoking it correctly is missing.

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

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

There are zero parameters, so the schema is trivially complete and the baseline is 4. The description's reference to 'every watched listing' provides the implicit selection scope, so no parameter documentation is necessary.

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 ('Re-check') and resource ('every watched listing') and states exactly what is reported: price changes and sold/removed status. This clearly distinguishes it from siblings like get_watch, get_watches, and watch_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?

It explicitly frames the tool as 'ideal for a scheduled agent' and explains the request policy per uncached listing, giving a clear recurring/maintenance use case. It does not name alternative tools or exclusion conditions, so it stops short of a 5.

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 destructiveHint=true and idempotentHint=true, so the description does not need to repeat those. It adds valuable context with 'No network requests,' disclosing that the operation is purely local and has no remote side effects, which goes beyond the structured 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 brief two-clause sentence that front-loads the primary action and resource, followed by a single high-value behavioral note. Every word contributes, with no filler or redundancy.

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

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

For a single-parameter destructive operation with an output schema and clear annotations, the description covers the essential purpose and an important behavioral nuance. It omits optional details like error behavior or return value, but those are largely covered by the output schema and structured 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?

The input schema fully describes the 'name' parameter with a pattern and an example. The description adds only the phrase 'by name,' which reinforces the parameter but does not meaningfully supplement the schema's already complete documentation. Baseline 3 is appropriate due to high schema 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 uses a specific verb ('Remove'), a clear resource ('a saved search'), and a scoping detail ('by name'). It clearly distinguishes the tool from siblings like save_search and list_saved_searches, making its intent unambiguous.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives, nor does it mention related operations like saving or listing saved searches. 'No network requests' hints at a local operation, but the description does not clarify the broader context or prerequisites.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds substantial beyond that: it discloses fuzzy free-text matching behavior, the up-to-3-polite-requests cost, the p25/median computation, and the benchmark mode nuance for local-vs-global pricing. 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?

Three dense sentences front-load the tool's purpose and unique output, then add the most important usage caveat and precision guidance. Every sentence earns its place; there is no fluff or repetition of schema content.

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 13-parameter tool with an output schema, the description is remarkably complete: it explains the computation, the request cost, the fuzzy-match behavior, the preferred parameters, and the benchmark mode context. The output schema covers return-value details, so the description does not need to restate them.

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 62%, and the description adds meaningful guidance beyond the schema: free-text scopes match fuzzily, manufacturerIds/models/referenceNumber give precision, and benchmark=global with a countries filter prices against the worldwide market. It does not elaborate on every parameter, but it enriches the most decision-critical ones.

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

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

The description names the exact deliverable: listings priced below market, computed from full-range stats, with results at or below the market p25 and their percentage below median. It clearly defines the resource scope and output, and this unique p25/median behavior distinguishes it functionally from siblings like search_listings and get_price_stats.

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

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

It gives clear when-to-use guidance: "The one-call answer to 'find me a good deal on X'." It also gives concrete preference guidance for precision: prefer manufacturerIds + models or referenceNumber over free-text. It does not explicitly name alternative tools or state when not to use it, so it stops short of a 5.

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 convey readOnlyHint and openWorldHint, so the safety profile is covered. The description adds value by revealing exact output fields and the numeric nature of the model id, but it does not go into deeper behavior such as pagination, ordering, or completeness guarantees. This is acceptable given the simple read-only nature and existing 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, no filler. The first sentence states what the tool returns; the second sentence gives actionable downstream guidance. Everything present earns its place.

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

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

For a one-parameter read-only tool with a detailed schema and output schema, the description is fully sufficient. It covers the purpose, the returned fields, and how to use the model id and brand id in related searches.

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

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

Schema description coverage is 100% and already explains the brand parameter with examples and accepted input forms (name, id, or slug). The description reinforces the connection to list_brads and search_listings, but does not add significant new parameter 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 verb ('List') and the resource ('a brand's model catalog'), and lists the output fields (model name, slug, numeric id). It is easy to distinguish from the sibling tool list_brands, which returns brands rather than 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?

The description explicitly tells the agent how to use the results downstream by pairing the model id with search_listings' models param and the brand id with manufacturerIds. It gives clear context for when this tool is useful, though it does not explicitly state when not to use it or name alternatives beyond the integration hint.

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 and openWorldHint, so the safety profile is covered. The description adds useful behavioral context by noting the inventory is 'current' and that the response has 'the same card shape as search_listings', giving the agent expectations about output consistency without needing to inspect the 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 compact and front-loaded with the core action and target resource. The second sentence provides a useful cross-tool reference without any fluff. 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?

For a simple read-only list endpoint with an output schema and safety annotations, the description covers the main purpose, the required parameter's source, and the expected card shape. It could be more explicit about pagination and sorting behavior, but the schema provides enough detail for those optional parameters, and the tool is otherwise complete enough to invoke 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 description reinforces the key parameter customerId and its provenance, which is helpful, but the schema already documents customerId. With schema description coverage at only 33%, page and sort are not explained in the description; however, their schema metadata (enum, default, min, max) partially compensates, so the description adds some but not enough meaning.

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

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

The description clearly states a specific verb ('List'), a specific resource ('a dealer's current inventory'), and the identifying key ('customerId'). It also ties the parameter to a specific source tool ('get_watch's sellerIds'), which distinguishes this tool from general search tools like search_listings.

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 context for when to use this tool: to fetch a dealer's current inventory using a customerId obtained from get_watch's sellerIds. It does not explicitly state when not to use it or name alternatives beyond the shape reference to search_listings, so it stops short of a full 5.

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 and openWorldHint, so safety is covered. The description adds meaningful behavioral detail: returned reviews include text, dealer replies and paging totals, and results can be filtered by star rating. This goes beyond the annotations without contradicting them.

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

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

Two dense sentences with no filler. The key action, the critical identifier caveat, the response contents, and the filtering option are all front-loaded and each clause earns its place.

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

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

For a read-only paginated review tool, the description is complete: it states the identifier source, the contents of the response, the filtering option, and paging totals. An output schema exists, so return structure does not need to be explained further.

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 baseline is 3. The description adds extra meaning for dealerId by specifying the exact source (get_watch's sellerIds) and warning against using the customerId. It also clarifies the stars filter, while size and offset remain well-documented in 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 starts with a specific action and resource: 'Fetch a dealer's customer reviews by their dealerId'. It also distinguishes the needed identifier from a common confusable ('NOT the customerId') and states the content (per-review rating, text, dealer reply, paging totals), which separates it from aggregate sibling tools like get_dealer_rating_summary.

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 usage context: use a dealerId coming from get_watch's sellerIds, not the customerId. It does not explicitly name alternatives like get_dealer_rating_summary for aggregate ratings, but the mention of per-review data and paging makes the intended use case reasonably 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?

Beyond the readOnlyHint annotation, the description discloses useful behavioral traits: ~8s latency per uncached dealer, 30-minute caching, up to 5 dealers, and per-dealer failures not breaking the batch. This materially helps an agent predict performance and failure behavior.

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

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

Two compact sentences deliver function, limits, performance, caching, use case, and failure semantics without redundancy. Each clause earns its place and the core purpose 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 single-parameter read-only batch tool with an output schema, the description covers the essential operational context: what it returns, batch size, latency, caching, and failure isolation. No critical information is missing.

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

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

The input schema already documents the dealerIds parameter with min/max, pattern, source hint, and latency. Schema description coverage is 100%, so the main description adds no new parameter meaning beyond reinforcing the max of 5 dealers.

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

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

The description states a specific verb and resource: returns star histograms and average ratings for up to 5 dealers in one batch call. The batch nature and dealer count clearly distinguish it from the singular get_dealer_rating_summary sibling.

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

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

The description gives clear usage context: use this to vet all shortlisted sellers at once. It does not explicitly name alternatives or say when not to use it, but the batch framing and 'all shortlisted sellers at once' make the intended use obvious.

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 significant behavior beyond the readOnlyHint and openWorldHint annotations: it makes 5 lightweight requests, takes ~8s uncached, and is cached for 30 minutes. It also explains that the summary is reconstructed from per-star counts, which is useful operational context for the agent.

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

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

Two tight sentences deliver the output definition, operational cost, caching, the usage scenario, and the sibling alternative. Information is front-loaded and every clause earns its place with no repetition of schema or annotation content.

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 one fully documented required parameter, an output schema present, explicit cost/latency/caching behavior, and a named alternative, nothing critical is missing. An agent can confidently decide when to call this tool and roughly what to expect in return.

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

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

Schema description coverage is 100%, and the schema already provides a precise, disambiguating description for dealerId: 'from get_watch's sellerIds (NOT the customerId). The tool description does not add extra param info, but none is needed because 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?

Description states the resource (dealer rating summary), the specific output (star histogram and weighted average rating), and how it is produced (reconstructed from per-star review counts). This clearly distinguishes it from the plural sibling, get_dealer_rating_summaries, and from get_dealer_ratings, which would contain individual ratings.

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 the agent when to use this tool: 'use it to vet an unfamiliar dealer before recommending a purchase.' It also gives the alternative condition: 'For several dealers, prefer get_dealer_rating_summaries.' This is direct routing guidance with 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?

Annotations already declare this read-only and open-world, and the description adds non-obvious behavioral context: one polite request, 24-hour caching, and approximate nature of prices. This goes beyond the structured annotations without contradicting them.

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

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

Two dense sentences front-load the resource and include a concrete example, while the cache and courtesy note occupies its own compact clause. There is no filler or repetition of schema 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?

Given the read-only annotation, fully documented schema, and presence of an output schema, the description provides enough for correct invocation: what content to expect, an example, and relevant caching behavior. Any routing nuance with siblings is a minor enhancement rather than a gap.

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

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

The input schema already fully documents both required parameters with accepted forms and examples, reaching 100% coverage. The description's Submariner example illustrates output content rather than adding parameter-level semantics, so the baseline score of 3 applies.

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

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

The description identifies a specific resource: Chrono24's editorial buying guide for a model, and lists concrete contents: history, cost insight, investment notes, and a per-reference approximate price table. This clearly distinguishes it from sibling listing, price, and search 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 implies when the tool is relevant—when an editorial, model-level buying guide is wanted rather than live listings or price stats—but it never explicitly names alternatives or states when not to use it. The cache and 'polite request' note addresses request behavior, not tool selection.

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 readOnly/openWorld annotations, the description discloses request counts, the >60-match bias threshold, and the interpolation behavior of spread mode. This gives an agent the non-obvious cost and estimation-quality details needed to invoke the tool responsibly.

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

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

Two dense sentences with no filler: the first states the deliverable and output fields, and the second explains the mode trade-off. The most important scoping and cost information 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 an 11-parameter tool with an output schema and readOnly/openWorld annotations, the description covers the non-obvious behavioral pieces: estimation method, bias condition, and request budget. Remaining parameter details are already present in the schema, so nothing essential for correct invocation is missing.

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

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

The schema already describes most parameters (73% coverage), including the sample modes and cross-references to list_filters, find_models, and list_brands. The description mostly restates the sample behavior rather than adding meaning for the other parameters, so it provides only marginal parameter-level 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 leads with the exact deliverable: 'Price statistics for a watch across Chrono24' and enumerates the specific outputs: min, p10/p25/median/p75/p90, max, and sample size. This clearly distinguishes it from listing-returning siblings like search_listings or get_watch.

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 explicitly explains when to use each sampling mode: default 'cheapest' is one polite request with lower-tail bias when >60 matches, while 'spread' adds requests and interpolates full-range percentiles. It does not explicitly name sibling tools as alternatives, but the mode-selection 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 already declare readOnlyHint=true, so the safety profile is covered. The description adds value by listing the response contents: reference, specs, box/papers, dealer info, photos, and canonical URL. It does not go into rate limits or external data freshness, but the read-only annotation lowers the burden.

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 dense sentence. It leads with the action and resource, then packs the most relevant return categories into a compact colon-separated list with no filler or redundancy.

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

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

For a one-id read tool with an output schema, readOnlyHint=true, and a fully described parameter, the description is sufficient. An agent can call it safely and know what to expect without missing prerequisites or important caveats.

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 documents the single 'id' parameter thoroughly, including a pattern and an example of extracting it from a listing URL. The description only repeats 'by id' and adds no extra parameter semantics beyond what the schema already provides.

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

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

The description opens with a specific verb and resource: 'Get full details for one Chrono24 listing by id'. It then enumerates the concrete content returned, which clearly differentiates this from siblings like search_listings, get_watches, and get_watch_photos.

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

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

The phrase 'one ... listing by id' implies the tool is for retrieving a single listing when the id is already known, but it never explicitly says when to prefer this over search_listings or get_watches, nor does it mention a way to obtain an id. 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?

The description adds valuable behavioral context beyond the readOnlyHint/openWorldHint annotations by disclosing that it 'runs politely and sequentially' and that uncached ids take ~4s each. This gives the agent realistic performance and rate-behavior expectations 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?

Two sentences with no filler: the first front-loads the core purpose, and the second supplies relevant operational behavior. 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?

For a single-parameter, read-only batched getter with an output schema and helpful annotations, the description supplies everything needed to invoke it correctly: resource, id format, batch limit, and pacing. No return-format explanation is required because the output schema exists.

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

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

Schema description coverage is 100%, and the schema already documents ids as an array of numeric strings with minItems 1 and maxItems 10. The description's 'up to 10' and 'uncached ids take ~4s each' add runtime context but do not materially deepen parameter semantics beyond the schema.

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

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

The description states a specific verb ('Get') and resource ('full details for a shortlist of up to 10 Chrono24 listing ids'), making the batch behavior explicit. The title's 'batch' and the 'up to 10' cap clearly distinguish it from the sibling get_watch without needing to name it.

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 batch usage through 'shortlist' and 'up to 10,' and the latency note helps set expectations, but it never explicitly says when to prefer this over get_watch or search_listings. There is no direct when/when-not or alternative routing guidance, so an agent must infer usage from 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 mark this as read-only and open-world, so safety is covered. The description adds useful behavioral context beyond the annotations: approximate image sizes ('~28KB each'), the fact that images are returned inline, and that CDN fetches are fast with no politeness delay needed. These are concrete behavioral details not present in the schema or annotations.

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

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

The description is two sentences with no filler. The primary purpose is front-loaded, followed by key operational details about image size and fetch speed. Every sentence adds valuable information, and the structure allows an agent to quickly understand both purpose and constraints.

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, a rich output schema, and read-only annotations, the description is complete enough for an agent to select and invoke it correctly. It covers purpose, visual inspection use case, payload size considerations, and speed expectations. The presence of an output schema means the description does not need to detail return structure.

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

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

Schema description coverage is 100%, so the schema already documents id, size, and maxPhotos meaningfully. The description добавляет minimal parameter-specific value beyond repeating the 'Large' size and image size. It gives the high-level purpose for the return data but does not need to, because the schema already covers parameter meanings.

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

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

The description states a specific verb and resource: 'Fetch a listing's photos as inline images.' The stated purpose of inspecting condition and authenticity cues makes it clear this is a visual inspection tool, distinguishing it from sibling search and watch-info tools. The singular 'listing' scope differentiates it from broader listing-related operations.

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 context for when to use this tool: when a listing's photos need to be visually inspected for condition and authenticity cues. It also adds operational guidance, noting 'Fast CDN fetches (no politeness delay needed),' which helps the agent plan calls efficiently. It does not explicitly state when not to use it or name alternatives, 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?

The description goes beyond the readOnlyHint annotation by disclosing that the tool makes exactly two polite requests and asserts parsing invariants. It also hints at operational behavior via the 'canary' metaphor. This is useful context that helps an agent predict the tool's side effects and intent.

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

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

Two tight sentences with no filler. The core behavioral concept is front-loaded ('Live canary'), followed by invocation guidance. Every word contributes meaning.

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 zero parameters, a read-only annotation, and an output schema, the description is largely sufficient. It explains what the tool does and when to run it. Minor ambiguity remains around what the health-check result looks like on failure, but the output schema presumably covers that.

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 100% schema description coverage, so there is nothing for the description to add to parameter semantics. The baseline of 4 applies because no parameters exist and no semantic clarification 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 clearly indicates this is a live health-check/canary tool that sends one search and one detail request to assert parsing invariants. The 'live canary' phrasing is slightly jargon-heavy, but combined with the title it conveys the tool's purpose. It does not explicitly differentiate itself from the sibling server_status, though the focus on Chrono24 parsing distinguishes it implicitly.

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 usage context: run after suspected Chrono24 markup changes or on a schedule. It does not explicitly discuss when not to use it or compare it with alternatives, but for a health-check tool the guidance is 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?

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds that there are 550+ brands and that ids are numeric, which is useful context, but it doesn't disclose details like default ordering or pagination.

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

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

Two sentences with no waste: the first states the core purpose and output, the second gives integration guidance. 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?

The tool is simple (one optional parameter, read-only, output schema present). The description covers purpose, output shape, and relationship to siblings. It could mention that omitting query returns all brands, but that's inferable from the schema and the description's 'List ... brands' phrasing.

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% because the query parameter is fully documented as an optional case-insensitive substring filter. The description adds a note about using a name with find_models, but that's downstream usage rather than new parameter semantics. 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 states a specific verb ('List') and resource ('Chrono24 watch brands') and specifies that it returns numeric ids. It also differentiates from siblings by showing how the ids/names are used with search_listings and find_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?

The description provides concrete downstream usage: use an id with search_listings' manufacturerIds, or a name with find_models. It doesn't explicitly state when not to use this tool, but the context and sibling names make the selection 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 this as read-only and open-world, so safety is covered. The description adds behavioral value by clarifying that the tool returns allowed facet values, not just filter names, and that an optional exact name can be provided. This goes beyond the schema and annotations without contradicting them.

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

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

The description is two sentences with no filler. The main action and resource are front-loaded, and the downstream usage tip is concise and actionable. 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?

For a simple read-only list tool with one optional parameter and an output schema, this description is complete. It covers what the tool returns, gives examples, and explains how to use the results. Nothing essential is missing.

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

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

Schema description coverage is 100%, so the optional 'name' parameter is already well documented in the schema. The description does not add additional parameter-level semantics, but it also does not need to because the schema fully explains the parameter's meaning and example 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 uses a specific verb ('List') and resource ('Chrono24 search facet filters'), and gives concrete examples of filter types. It clearly differentiates this from sibling tools like list_brands or find_models by focusing on search facets and their allowed values.

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 the returned values with search_listings' facets param, which tells an agent why this tool exists and how it fits into a workflow. It does not explicitly discuss when not to use it or compare it to alternatives, but the search_listings reference provides strong contextual 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 already declare readOnlyHint=true and openWorldHint=false. The description adds a useful behavioral trait beyond those annotations: 'No network requests,' which implies low latency and no external side effects. It also clarifies what the response contains, though the output schema exists.

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

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

Two short sentences with no wasted words. The core operation is front-loaded, and the additional behavioral note ('No network requests') earns its place as valuable context.

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

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

For a zero-parameter, read-only, deterministic tool with an output schema and annotations, the description is fully sufficient. It tells the agent what the tool does, what information is returned, and one non-obvious behavioral trait.

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; there is nothing meaningful to add. The description correctly omits parameter details since none exist.

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

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

The description states a specific verb ('List'), a clear resource ('all saved searches'), and the data returned ('scopes and last-checked times'). This distinguishes it from sibling tools like search_listings or list_filters, which operate on different resources.

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 intended usage is implied by the name and description, but no explicit when-to-use or when-not-to-use guidance is given. It does not name alternatives or exclusions, though the zero-parameter nature makes this a minor gap.

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 cover readOnly/destructive/idempotent hints. The description adds useful behavior: it persists across restarts, seeds with current listings, and is a 'one polite request to seed'. This expands beyond the structured annotations without contradicting them.

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

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

Two sentences with no filler. The first sentence delivers the core action and consequence; the second adds persistence and the polite-request constraint. 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?

The description is functionally clear but omits practical invocation details for a 12-parameter tool: how to construct the rest of the scope, whether all filters are optional, or what happens on re-saving an existing name. The presence of an output schema reduces the need to describe return values, so this is adequate but not 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 about 58%, but the description adds no parameter-specific guidance. It does not explain the search-scope fields, nor compensate for undocumented parameters like year, priceTo, priceFrom, condition, and countries. The word 'named' merely echoes the required name parameter already described in 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 uses a specific verb and resource: 'Save a named search scope and seed it with the current listings'. It clearly distinguishes itself from siblings like list_saved_searches, check_saved_searches, and delete_saved_search by explaining the save-and-seed behavior and the later 'only NEW listings' reporting.

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 explains when to use the tool: to create a persistent named search so check_saved_searches later reports only new listings. It does not explicitly mention alternatives such as search_listings for immediate results or when not to use this tool, so it falls short of a full 5.

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 readOnlyHint and openWorldHint annotations, the description discloses meaningful operational behavior: 60 listings per page, ~4s polite request per uncached page, a 5-page cap, and deduplication. These details help the agent anticipate cost, latency, and output semantics without guessing.

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 deliver the core behavior, constraints, and usage guidance with no filler. The most important operational facts are 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?

Given the output schema exists, the readOnly/openWorld annotations cover safety, and the sibling list is available, the description supplies the essential selection and invocation context: exhaustive aggregation, deduplication, paging behavior, and when to choose search_listings instead. No critical gap remains for an agent deciding to call it.

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

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

Schema description coverage is 50%, so the description does not need to compensate heavily. It adds significant meaning for maxPages by explaining page size, request pacing, and the 5-page cap, which goes beyond the schema's bare default/max fields. Other parameters remain adequately covered by their names/types and the few existing 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 states a specific action ('Aggregate multiple result pages into one deduplicated list') and clearly identifies the resource (result pages/listings). It also differentiates from search_listings by framing search_all for exhaustive scans, so an agent can distinguish it from the main sibling without opening the schema.

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

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

The description explicitly says 'Use for exhaustive scans; prefer search_listings for quick looks,' which gives both a positive condition and a clear alternative. This directly answers when to choose this tool versus the most relevant sibling.

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 and openWorldHint, and the description adds meaningful behavioral context: it returns up to 60 cards per page, lists the exact fields included, and notes fuzzy free-text matching. This goes beyond the structured annotations without contradicting them.

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, each earning its place: the first states the purpose, the second summarizes return shape and shortlisting use, and the third gives parameter strategy. No filler or redundancy.

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

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

For a read-only search tool with an output schema and fully documented parameters, the description is complete: it covers result page size, returned fields, fuzzy vs. precise search, and the relationship to find_models. Nothing critical is missing for an agent to decide whether and how to call it.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3, but the description adds useful cross-parameter guidance: query is optional when filtering by manufacturerIds/models/reference, and precise model search depends on find_models. This helps the agent choose the right parameter combination rather than just understanding individual fields.

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

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

The description names a specific action ('Search') and a specific resource ('Chrono24 watch listings'), and immediately distinguishes the tool's value by describing the card fields returned. It is clearly differentiated from siblings like search_all or get_dealer_listings by focusing on listing search and shortlisting without detail fetching.

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 how to search: free-text queries are fuzzy, and precise model scoping should use manufacturerIds + models from find_models or referenceNumber. It stops short of explicitly stating when to prefer sibling tools like search_all or get_dealer_listings, but the guidance is clear and actionable.

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?

It explicitly discloses a key behavior beyond the readOnlyHint: 'No network requests'. It also clarifies that it inspects browser state, cache, disk-cache freshness, and politeness settings, so the agent knows what kind of internal state is read. The description is consistent with annotations, not contradictive.

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 very compact and front-loaded: it starts with the core purpose ('Diagnostics'), lists the specific areas covered, then adds a critical behavioral note and a practical use case. Every sentence earns its place; there is no fluff or irrelevant detail.

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 has no parameters and has an output schema, the description provides enough context for correct selection and invocation. It explains what state is examined, that no network request occurs, and when to use it. Nothing important is missing for an agent to call this tool appropriately.

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 there is no parameter surface for the description to clarify. Baseline for zero params is 4, and no additional param documentation 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 clearly identifies the tool as a diagnostics tool covering specific areas: browser state, cache and disk-cache freshness, and politeness settings. It avoids being a tautology and distinguishes itself from siblings by explicitly noting 'No network requests', which sets it apart from data-fetching 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 gives a clear trigger for use: 'useful when calls feel slow or stuck'. It does not name alternative tools or state when not to use it, so it falls just short of full guidance, but the context is sufficiently clear for a zero-parameter diagnostic 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 already declare destructiveHint=true and idempotentHint=true, covering mutation and repeat-safety. The description adds a non-obvious operational trait, 'No network requests', which tells the agent the action is local and has no network side effects. This does not contradict 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?

Two short sentences with no filler: the core operation isfront-loaded, and the behavioral note is kept brief. Every word earns its place.

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

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

For a single-parameter, low-complexity tool, the description plus annotations and output schema cover the essentials: what it does, safety profile (destructive/idempotent hints), and network behavior. No return-format explanation is needed because an output schema exists.

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 provides only the id property with a digit pattern and no description. The tool description's 'a listing' implies id refers to the listing being unwatched, but it never explicitly maps the parameter or clarifies whether id is a listing ID versus a watch entry ID. With 0% schema description coverage, this is a meaningful gap.

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

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

The description states a clear verb ('Stop tracking') and a specific resource ('a listing'), precisely identifying the tool's operation. The name and sibling set (watch_listing, get_watches) make the inverse relationship obvious, so an agent can distinguish it from related 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?

Usage is implied: an agent should call this when it no longer wants a listing tracked, and it is the natural counterpart to watch_listing. However, the description does not explicitly state when to choose it over alternatives or mention prerequisites/exclusions, leaving routing to inference.

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 as read-only and open-world. The description adds useful behavioral context: per-item requests are polite, up to 10 items allowed, and results include per-item stats plus aggregate sums. No contradictory behavior is disclosed.

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

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

Two sentences with no filler. The key capability, limits, and item input pattern are all front-loaded and each clause 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 output schema and annotations, the description provides enough for an agent to call the tool correctly: item count, required scope fields, optional fields, and result composition. It could be slightly more explicit about what counts as a 'scope field,' but the schema's items description covers that.

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

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

The description explains how to populate the items array: give each watch a reference number or query and optionally condition/year. It also notes the 'one polite request per item' constraint, which adds meaning beyond the schema's sparse property 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 appraises up to 10 watches and returns per-item price stats plus portfolio totals. This is a specific action on a specific resource, though it does not explicitly contrast with sibling tools like get_price_stats.

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 context: use this for appraising multiple watches in one call and getting portfolio-level totals. It does not explicitly state when to prefer a single-watch tool, but the batch and portfolio framing makes the intended use understandable.

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 persistence information ('Persists across restarts') and a usage hint ('One polite request to seed') beyond the annotations. Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the description complements rather than contradicts them.

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 the main purpose, no redundant wording. The phrase 'One polite request to seed' is slightly cryptic but conveys a meaningful behavioral hint. Overall compact and efficient.

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

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

For a two-parameter tool with idempotent and non-destructive annotations, the description covers what is tracked, persistence, and the companion reporting tool. Since no output schema is provided, pointing to check_watched_listings for results is sufficient guidance.

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 full descriptions in the schema, and the tool description does not add meaning beyond them. The description's mention of tracking changes repeats schema language, so with 100% schema coverage the baseline of 3 is appropriate.

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

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

States a specific verb 'Track' and resource 'specific listing', with clear purpose 'price changes and sold/removed status'. It also distinguishes from sibling check_watched_listings by noting that tool reports what changed, making the role of this tool 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?

Names the companion tool check_watched_listings as the reporting mechanism, implicitly defining the workflow: watch first, then check changes. It does not explicitly mention when to avoid this tool or use unwatch_listing, but the intended context is clear.

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