TickerMint

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

Annotations already cover read-only, idempotent, non-destructive safety, yet the description adds crucial behavior: only highs set in the last 7 days that still hold, tracking start dates, USD currency, and the high_is_all_time/high_scope caveat. That is meaningful context an agent could not infer from annotations alone.

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 the trigger, then the return definition, then the important release-date caveat. The parenthetical tracking-date example is dense but earns its place by preventing a false all-time interpretation.

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?

An output schema exists, so the description need not enumerate return fields, and it still explains the temporal window, currency, and high-scope caveat. That is enough for an agent to call this correctly.

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

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

Schema coverage is 100%; the game enum and limit range are fully documented in the input schema. The description adds no new constraint or format detail for either parameter, so the baseline 3 applies when the schema carries parameter semantics.

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

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

States a specific verb and resource: returns cards at their highest market price. The scope (one game, record price) separates it from generic pricing siblings, but it never names all_time_lows, so sibling differentiation is implied rather than explicit.

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?

Gives a clear trigger: 'Use this when the user asks which cards in one game are at a record price.' However, it offers no when-not conditions or named alternative, so an agent knows the intended situation but not what to choose instead for lows.

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 the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds real behavioral substance on top: the $5 floor, the 50%-below-high threshold, the `low_scope` all-time caveat for newer cards, and that figures are USD. It says nothing about ordering, pagination, or what `limit` truncates, which keeps it from a 5.

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 the trigger, then the qualifying rules, then the returned fields — no filler. The `low_scope` parenthetical is the only mildly dense spot, but it earns its place by heading off a data-interpretation error.

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

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

With an output schema present, the description doesn't need to enumerate return fields, yet it usefully names 'the high and the percent below it, in USD'. Combined with the threshold rules and the all-time-scope caveat, an agent has enough to call this correctly; only result ordering/limit semantics are absent.

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

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

Schema coverage is 100% and the game enum is fully documented in the schema, so the schema carries parameter meaning. The description only reinforces that results are scoped to 'one game'; it adds nothing about `limit` (default 25, max 200) or which parameter it affects. 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 and resource ('which cards in one game are at their lowest price or have crashed') and pins down the exact qualifying criteria: $5+ market price, at least 50% below the high. It never names the obvious counterpart sibling (all_time_highs) or distinguishes itself from movers, so sibling differentiation is left implicit.

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 opening clause gives a clear triggering condition ('when the user asks which cards ... are at their lowest price or have crashed'), which is enough to route most calls correctly. It stops short of stating when NOT to use it — e.g. that all_time_highs is the mirror tool for the opposite question.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), it discloses that prices are raw/ungraded only, are not an appraisal of a specific copy, are denominated in USD, and carry a price date. It also names the returned `headline` field and the page URL, giving the agent real behavioral context the structured fields do not.

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 the usage trigger, then the return shape, then the limitation and prerequisite. Every sentence carries distinct information with no repetition.

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

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

An output schema exists, yet the description still usefully previews the key return fields and the raw-only caveat. Combined with the explicit prerequisite and the price-date disclosure, an agent has everything needed to call it correctly for a single-parameter read 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 100% and the schema already says the parameter is a 'TickerMint product_id from search_cards,' so the description's 'Needs a product_id from search_cards' mostly restates it. Baseline 3 applies since the schema does the heavy lifting; the description adds no format or edge-case detail beyond the origin.

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

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

States a specific verb and resource — pricing one specific card or sealed product for today — and immediately narrows the scope to the 'latest daily' TCGplayer market/lowest listed price per printing. It is readily distinguishable from siblings like price_history (historical), set_prices, and sealed_prices.

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 trigger is explicit: 'Use this when the user asks what one specific card or sealed product is worth today,' and the prerequisite 'Needs a product_id from search_cards' routes the agent to the right preceding call. It lacks an explicit exclusion sentence (e.g., 'for trends over time use price_history'), leaving that contrast implied by the word 'today.'

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

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

Annotations already declare readOnly, idempotent, closed-world and non-destructive, so the safety profile is covered. The description adds useful scope detail beyond that: results are per-printing, prices are today's market in USD, and the move window is 90 days — the kind of context annotations cannot express.

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

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

A single sentence with zero filler, front-loading the trigger condition ("after `search`") followed by the payload the tool returns. Nothing redundant.

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

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

With an output schema present, annotations covering safety, and one required param, the description is complete enough to call the tool correctly. The only remaining gap is not clarifying how this differs from the `card_price` and `price_history` siblings.

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

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

Schema coverage is 100% and the single `id` parameter is already documented as "Product id from `search` results." The description repeats the same provenance hint without adding format or edge-case detail, so the schema is doing 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?

States a specific verb (read) and resource (one product) and enumerates exactly what comes back: today's market price per printing in USD, 90-day move, and page URL. It clearly distinguishes itself from `search`, but does not distinguish itself from the sibling `card_price`, which sounds like it offers overlapping capability.

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?

"Use this after `search`" gives an explicit sequencing rule and tells the agent the id must come from a prior search. It stops short of any when-not guidance or pointing at `card_price`/`price_history` as alternatives for other price needs.

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 read-only annotations, the description discloses result composition ('up to 25 singles'), ranking method ('today's raw market price (USD)'), included fields ('set and printing'), and an important boundary ('Raw prices only, not graded values'). These details materially help an agent understand what the tool returns and what it does not cover.

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 tight sentences, front-loaded with the usage trigger, followed by return details and an exclusion. No sentence is wasted.

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

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

For a two-parameter, read-only list tool with an output schema, the description covers usage, ranking, included data, currency, and exclusions. An agent has enough information to invoke it correctly without needing further explanation.

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 already documents both parameters, including the game enum and the 1–25 limit range. The description reinforces 'one game' and 'up to 25' but adds no syntax or selection guidance 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 resource (most expensive/most valuable cards), scope (one game), and temporal qualifier ('right now'). The phrase 'today's raw market price' distinguishes it from sibling tools like all_time_highs and price_history 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?

It gives an explicit usage trigger: 'Use this when the user asks for the most expensive or most valuable cards in one game right now.' It also implicitly excludes historical comparisons and graded values, though it does not explicitly name alternatives such as all_time_highs or card_price.

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

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

Annotations already declare read-only, idempotent and non-destructive behavior, so the description is not carrying the safety burden. It adds genuinely non-obvious behavior: results are filtered to cards worth $5 or more and ranked by percentage rather than absolute price change, which materially affects how the agent interprets results.

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

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

Three short sentences: trigger first, then the returned metric and its filter, then the interpretive caveat. No restated title, no filler, and each sentence adds a distinct fact.

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?

An output schema exists, so return-shape explanation is not required, and the description supplies the ranking basis, price threshold and scope caveat an agent needs to present results correctly. Minor gap: no indication of whether a game with too few qualifying cards yields an empty set.

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

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

Schema coverage is 100% with per-parameter descriptions and an enum, so the schema already documents days, game and limit. The description restates the day range without adding syntax or defaults, and never mentions the limit parameter's effect on result size. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific question the tool answers (which cards rose or fell the most) plus the exact metric returned: biggest percentage moves with start and end market price. That metric-based framing separates it cleanly from siblings like most_valuable and all_time_highs.

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?

Opens with an explicit trigger condition ('when the user asks which cards in one game rose or fell the most recently') and adds a scope exclusion ('describes past moves only; not a prediction'). It stops short of naming which sibling to use for alternate questions such as all-time extremes, which is why it is not 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 readOnly, idempotent, non-destructive, and closed-world. The description adds genuinely new context beyond that: data granularity per printing, USD currency, the 7-1000 day window, and the February 2024 data-start caveat. The 'past prices only, no forecasts' line usefully prevents a wrong expectation.

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 tight sentences: usage trigger first, return shape second, scope limit last. Every clause carries information an agent needs; nothing is repeated from the schema except a harmless restatement of the day range.

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?

An output schema exists so return formatting is covered, and annotations carry the safety profile. Combined with the explicit data-start, currency, and no-forecast notes, an agent has everything needed to call this correctly and set expectations.

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 earns an extra point by adding the data-availability caveat ('history starts February 2024, later for newer cards'), which tells the agent that a large `days` value may return a shorter series — information the schema does not carry.

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

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

States a specific verb-and-resource pair: returns the daily market price per printing over the last `days` days in USD. The trigger framing ('going up or down', 'worth on a past date') separates it from snapshot tools like card_price, but no sibling is named explicitly.

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

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

Opens with an explicit when-to-use trigger list covering trend questions, period movement, and historical point-in-time lookups. It does not state when NOT to use it or name the alternative (e.g. card_price for the current price), so routing is inferred rather than spelled out.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds behavior not in the annotations: currency (USD), the 30-day percent-change metric, and the most-expensive-first sort order. It doesn't say what happens when limit is omitted or how the list is paginated, which keeps it from a 5.

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 with no waste: the trigger comes first, then the return shape, then the alternative. Each sentence carries distinct information an agent needs.

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?

Output schema exists, so return values needn't be re-explained, and the game enum plus limit range are fully documented in the schema. What remains thin is list-size/pagination behavior at the default limit, a minor gap for a simple read tool.

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

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

Schema description coverage is 100% with an enum on game and a documented limit range, so the schema carries the parameter burden. The description only echoes 'one game' and implies ordering; it adds no format or tuning guidance beyond structured fields. 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?

Specific verb+resource with clear scope: sealed product prices for one game, with the product categories (booster boxes, ETBs, bundles, packs, tins, cases) enumerated so the agent knows exactly what's covered. It also names what it returns (USD market price + 30-day change, sorted most expensive first), which separates it cleanly from card_price and set_prices.

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

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

Explicit trigger: 'use this when the user asks about sealed product prices in one game,' plus an explicit alternative for the contrasting case ('for one named product, search_cards plus card_price is more direct'). The routing decision is fully resolved without opening a schema.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds value beyond that by disclosing the result cap ('up to 10 matches') and the id handoff to `fetch`, though it says nothing about matching behavior (substring vs exact, fuzzy) or what happens when nothing is found.

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

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

Two sentences, zero filler. The purpose and supported games come first, then the return shape and the next-step call to `fetch`. Nothing is repeated from the title or annotations.

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

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

An output schema exists, so return fields needn't be explained, and the description still volunteers the result limit and the id-to-`fetch` link, which is the key operational detail. The one missing piece is disambiguation from the nearly identical sibling `search_cards`, which matters for an 11-tool namespace with overlapping names.

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

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

Schema coverage is 100% and the single parameter is documented as 'Card or sealed product name.', so the schema carries the load. The description reinforces the name-based query intent and the product-type scope, but adds no syntax, casing, or partial-match semantics beyond the schema — the baseline 3 applies.

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

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

The description gives a specific verb ('look up') and resource ('trading cards or sealed products'), and enumerates the supported games, so the agent knows exactly what domain is searched. It falls short of a 5 because it never distinguishes this tool from the close sibling `search_cards`, leaving the agent unable to tell the two apart for card-only queries.

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 states the usage context ('by name') and prescribes the follow-up workflow by saying the returned ids should be passed to `fetch`, which is genuinely useful routing. However, with a sibling literally named `search_cards` in the same toolset, the absence of any when-to-use-this-vs-that guidance is a clear 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 declare readOnly, idempotent, non-open-world, so the description is free to focus on what annotations cannot express: the 25-match result cap, the exact fields returned, the USD price currency, and the six-game coverage boundary. That is meaningful added context beyond the structured hints.

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

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

Three sentences, front-loaded with the trigger and the reason an agent would call it, then result shape, then coverage limits. No filler, though the return-field enumeration is slightly verbose given an output schema exists.

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 with full schema coverage and an output schema, the description supplies everything essential: trigger, purpose of results, result cap, currency, and supported games. The only gap is guidance on when its sibling `search` is the better choice.

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 query/game/limit are already well documented, and the enum values and 1–25 range appear in the schema rather than the description. The description only indirectly reinforces the limit ('up to 25 matches') and adds no syntax guidance beyond the schema's own example. Baseline 3 applies.

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

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

Specific verb+resource ('search_cards' for a card/product lookup) plus the explicit motivation — obtaining product_id or group_id for downstream calls. It also states scope (the six supported games) and output shape, which lets an agent distinguish it from card_price, set_prices, or search without opening any 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 opening clause gives a concrete trigger ('when the user names a trading card or sealed product') and names the downstream tools that consume its output, which is a genuine routing signal. It does not, however, say when to prefer the sibling `search` or `fetch` instead, leaving one comparison 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 already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely new behavioral context: USD currency, cheapest-printing basis per collector number, parity with the set page figure, the 25/10 result caps, and that master set totals are labeled separately from companion sets. Only return-shape and pagination/caching behavior are unstated.

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

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

Front-loaded with the use case, then the return contents, then the ID dependency — a sensible ordering with no filler sentences. It is dense and long-sentenced, though every clause (basis, currency, caps, subset handling) contributes distinct information.

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

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

For a one-parameter, read-only, idempotent tool with an output schema and full schema coverage, nothing an agent needs to call it correctly is missing: trigger conditions, ID source, and the exact scope of what is priced are all stated.

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

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

Schema coverage is 100% and there is a single required integer parameter, so the schema already carries the load. The description still adds value by stating the parameter's origin ('Needs a group_id from search_cards'), confirming it is a set identifier rather than a card or product id.

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

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

The description gives a precise verb-plus-resource picture: it returns set-level price totals (completion cost, master set total, top 25 singles, 10 sealed products, companion subsets). That aggregate framing implicitly separates it from card-level siblings like card_price and sealed_prices, but it never names those siblings explicitly.

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

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

It gives concrete user-intent triggers: 'when the user asks what a set is worth, what it costs to complete, or which cards in one set are the most valuable,' plus the prerequisite that group_id comes from search_cards. There are no explicit exclusions (e.g., 'for a single card use card_price'), 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.