Irish Used Car Market Data

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

Annotations already declare the safe read-only, idempotent, non-destructive profile, so the description is free to add value beyond them — and it does: per-call cost (0.01 USDC via x402), the free no-data case, and the returned verdict/margin/comparables/price-history payload. The billing model in particular is critical and is nowhere in 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?

Four compact sentences, front-loaded with the usage constraint and prerequisite, then defaults, then return contents, then cost. 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?

Despite an output schema existing, the description still summarizes the verdict semantics and cost model, and it covers the one real ambiguity (which platform default applies). Nothing an agent needs to call this 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?

Schema coverage is 100%, so both parameters are already documented, including the source_platform enum and default. The description restates the carzone default but adds no syntax or format meaning beyond the schema, so 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?

States a specific verb ('assess') and a singular resource ('one listing'), and the constraint 'you already have an id for' immediately distinguishes it from the feed/lookup siblings. An agent can tell it apart from get_vehicle_listing_by_id or get_irish_auto_arbitrage_feed 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?

Explicitly names the two sibling endpoints to call first to obtain a listing_id, giving a concrete prerequisite workflow rather than implied context. The only minor omission is an explicit 'do not use for X' exclusion, but the named alternatives cover the routing decision.

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, but the description adds behavior they cannot express: the 5-listing minimum, the 404 failure mode, and the x402 cost model (0.01 USDC per call, no-data results free). That is exactly the operational context an agent needs before invoking a paid tool.

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

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

Four compact sentences, front-loaded with purpose and scoping, then cost/error handling. Each sentence carries distinct load: scope, precondition, alternative, price. No filler or restatement of the title.

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 structure need not be re-explained, yet the description still summarizes the key metrics. Combined with the documented error path and pricing, an agent has everything required to decide and call correctly.

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

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

Schema description coverage is 100% – make, model, and fuel_type are each documented with defaults, examples, and an enum, so the schema carries the parameter burden. The description adds no format, casing, or defaulting guidance beyond what the schema supplies, so the baseline of 3 applies.

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

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

States a specific verb+resource ('estimate depreciation') and immediately defines the computed outputs (median price by model year, year-on-year change, price change per 10,000 km). It also names a sibling it is not (market_stats) and the reason for the distinction, so an agent can route without opening either 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?

Explicit when-to-use-not: 'Use market_stats instead for a simple market overview without depreciation calculations.' It also states the data precondition ('needs at least 5 listings; otherwise returns 404') and the commercial condition (charged vs free), leaving nothing 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 declare readOnly/idempotent/non-destructive/non-open-world, so the safety profile is covered. The description still adds real value beyond them: a concrete rate limit (10 calls/day per IP), cost (free), and a reliability caveat pointing to Revenue.ie for verification. It stops short of describing calculation edge cases or precision, hence 4 rather than 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 tight sentences with no waste: purpose first, caveat/alternative next, operational constraints last. The routing information is front-loaded where an agent will act on it.

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

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

For a read-only estimator with a full schema, an output schema, and complete annotations, the description supplies everything else an agent needs: what it computes, how accurate it claims to be, the sibling alternative, and the throttling limit.

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 every parameter is already documented (including the nox_mg_km default of 40, which the description never mentions). The description echoes OMSP/CO2/fuel type but adds no format, unit or default detail beyond the schema — baseline 3 is correct 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 verb (estimate) and resource (Vehicle Registration Tax and NOx levy for an Irish-registered vehicle), plus the inputs it derives from (OMSP, CO2, fuel type). It explicitly names and contrasts itself with the sibling import_calculator, so an agent can route between them without opening either 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?

Gives both the use case ('Use to estimate...') and the exclusion, naming import_calculator as the right tool when a full UK-to-Ireland landed-cost and margin estimate is needed. It also adds an accuracy caveat ('Estimate only; verify against Revenue.ie') that sets expectations about authority of the result.

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 establish read-only, idempotent, non-destructive behavior, so the bar is lower. The description adds genuinely non-structured traits: a 0.01 USDC x402 cost per call, free no-data results, and that output is counts only with no prices. It does not cover error behavior or any rate limits beyond cost, so it stops just short of full transparency.

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

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

Front-loads purpose and scope, then the alternative, then cost. Dense but every clause earns its place; the single long first sentence carries a lot of enumeration that could be trimmed slightly, which keeps it from a 5.

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-value detail is not needed. Between the description (content scope, cost, no-data behavior, alternative tool) and the annotations (safety profile), an agent has everything required to select and invoke it correctly.

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

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

Schema description coverage is 100% and both parameters are documented there as optional, case-insensitive filters. The description restates that filtering by county and/or make is optional but adds no syntax, matching behavior, or default semantics beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('active used-car listings') plus the exact scope of the payload: county/make breakdown, 24h additions, 7d removals, source count, last refresh. It explicitly names the sibling it is not (get_inventory_summary), so an agent can route between the two without opening either 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?

Opens with the intended use case ('market coverage and supply analysis') and gives an explicit when-not rule with the named alternative: use get_inventory_summary for a single headline count. Both the selection condition and the alternative are stated, not implied.

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 the description goes further with details annotations cannot carry: the 'one number plus timestamp' return shape, the metered cost of 0.005 USDC per call via x402, and the fact that no-data results are free. Cost and output shape are exactly the behavioral context an agent needs here.

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: return shape first, exclusions and the alternative second, pricing last. No repetition of the title or 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 zero-parameter read tool with an output schema already present, the description covers everything an agent needs: scope, return shape, the alternative for detail, and the cost model. Nothing material 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 tool takes zero parameters (empty object schema, 100% coverage), so the baseline is 4. The description confirms there is nothing to filter by, reinforcing that no inputs are expected or accepted.

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 with explicit scope: the count of active used-car listings in Ireland, plus a timestamp. It also names the sibling it is not (get_inventory_breakdown), so an agent can separate it from the 12 other tools without opening a 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?

Explicitly excludes what it does not do ('No breakdowns and no prices') and routes the agent to get_inventory_breakdown for county, make, turnover and freshness. The when-to-use condition and the alternative are both stated rather than implied.

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 cover safety (readOnly, idempotent, non-destructive, closed-world), but the description adds behavioral context the annotations cannot: the 0.05 USDC per-call cost via x402, the free no-data case, the comparable-set definition (same make/model/fuel/transmission, within 1 year and 30,000 km), and the result payload including market median and comparable count.

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 usage trigger and the ranking definition, then alternatives, then cost. Every sentence carries unique information; no filler or repetition of the title.

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

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

With an output schema present, return-value explanation is not required, and the description still conveys the eligibility logic, cost model and sibling routing. An agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents make, limit and min_margin_eur. The description adds only a marginal nuance for min_margin_eur (the margin is measured 'after a cost buffer'), which is useful but does not go far beyond the schema baseline.

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

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

Names a specific verb and resource (ranked list of Irish used-car listings priced below the median of comparable cars) and defines the comparison logic precisely, so the agent knows exactly what is being returned rather than just 'deals'.

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

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

Explicitly states when to use it and names two alternatives with the conditions that select them: get_new_deals for recently discovered deals, get_price_drops for just-reduced listings. Nothing is left 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 cover read-only/idempotent/no-destruction, and the description adds traits they do not: per-call cost (0.02 USDC via x402), a free no-data outcome, and incremental polling semantics. That is exactly the value-add expected when annotations exist.

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 front-loaded sentences with no filler: purpose, operating pattern, alternatives, then cost. Every 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?

With an output schema present, return values need not be explained, and the description still covers defaults, polling mechanics, pricing, and routing to siblings. Nothing needed to invoke 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?

Schema coverage is 100%, so the baseline is 3; the description goes slightly beyond by explaining how to drive `since` incrementally (pass the previous call's time) and restating the 24-hour default window. It does not explain make/limit/min_margin_eur beyond what the schema documents.

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 with scope: 'returns deals first seen by us since a timestamp (default: last 24 hours).' This clearly distinguishes it from the ranked feed and price-drop siblings without requiring a schema read.

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 explicit when-to-use ('poll for fresh opportunities'), an operating pattern ('call on a schedule with the previous call's time'), and names two alternatives with the conditions that select them (get_irish_auto_arbitrage_feed for current ranked lists, get_price_drops for discount signals).

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 cover the safety profile (read-only, idempotent, non-destructive, openWorld=false), and the description goes further in the ways that matter: it discloses the x402 paywall at 0.02 USDC per call, that no-data results are free, and the provenance limitation that price history only exists from our first observation of a listing. That last point materially affects interpretation of the days window and is not derivable from the 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?

Three sentences with no filler: purpose first, alternative second, cost/provenance third. Every sentence carries information an agent would otherwise have to guess.

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 values need no explanation. With zero required parameters, a 60-day cap on the window, cost, provenance limits and the sibling alternative all covered, nothing an agent needs in order to call this 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?

Schema coverage is 100% and each parameter already carries a range and description, so the schema does the heavy lifting and a 3 is the correct baseline. The description adds only marginal meaning, notably that the 'drop' is the latest cut, which loosely frames min_drop_pct, and that the window is a look-back.

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 ('listings whose price dropped within the last N days') and enumerates the returned fields (original, previous, current price, percentage cut). It also names the sibling it is not (get_irish_auto_arbitrage_feed), so an agent can disambiguate 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?

Gives an explicit use case ('find motivated sellers') and an explicit alternative with the condition that selects it: get_irish_auto_arbitrage_feed for below-market ranking even when there was no recent price cut. It also discloses the cost model, which affects whether an agent should call it at all.

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, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds a genuinely non-derivable behavioral fact — that this call is free — plus what the response will contain, which is useful context beyond the annotations.

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

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

One front-loaded sentence with no filler: the resource, its contents, and the cost are all packed in and nothing is repeated from the schema or annotations.

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

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

For a zero-parameter, read-only discovery tool that already has an output schema, the description covers what the agent needs: purpose, contents, and cost. The only omission is explicit guidance on when in the workflow 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?

There are zero parameters, so there is nothing for the description to disambiguate; the baseline for a param-less tool applies.

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

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

States a specific verb and resource ('Describes this service') and enumerates the exact contents returned: available data, every tool with its price, and how payment works. Against siblings like price_check or get_inventory_summary, this is unmistakably the meta/discovery tool.

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

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

The description implies a discovery/orientation role and notes the call is free, which hints at when it is worth invoking, but it never says to call it before the data tools or under what conditions an agent should prefer it. Usage is inferred rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so safety needs no restating. The description adds genuinely non-structured behavior: a 0.005 USDC x402 charge per call, the fact that no-data results are free, and that exactly one row is returned. It stops short of covering rate limits or error/auth behavior, but the added context is substantive.

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 when-to-use clause and the returned-fields list are front-loaded, and the two sibling exclusions follow immediately. It is dense but every sentence carries routing or cost information; the only slight bloat is re-listing output fields that the output schema already covers.

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-value mechanics need not be explained, and annotations carry the safety profile; the description still supplies the pricing model and the free no-data case. For a two-parameter lookup with rich structured metadata, nothing an agent needs to call 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?

Schema description coverage is 100%, so both parameters (listing_id and source_platform) are already documented in the schema with enums, defaults, and examples. The description's note that the id comes from another call or a dealer site paraphrases the schema rather than adding syntax or format detail. Baseline 3 applies when the schema carries the parameter burden.

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

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

States a specific verb (look up) and resource (one Irish car listing by id) and enumerates what comes back: make, model, year, price, mileage, status, days on market, market-median comparison, and VRT breakdown. It explicitly separates itself from get_irish_auto_arbitrage_feed and analyze_listing, so an agent can route without opening sibling schemas.

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 triggering condition ('when you already have a listing id from another call or a dealer site') and names two alternatives with the conditions that select them — ranked below-market deals go to get_irish_auto_arbitrage_feed, closest comparables/price history go to analyze_listing. Nothing about when-not-to-use is left 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 only declare it is a safe, idempotent, closed-world read; the description adds the non-obvious traits an agent needs: duty and import VAT silently default to 0 and must be set by the caller, outputs are estimates not quotes, the call costs 0.01 USDC via x402, and no-data results are free. That is real behavioral disclosure beyond the structured fields.

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 decision rule, then the output composition, then the alternative and cost caveat. No filler; the pricing sentence earns its place because it affects whether the agent calls at all.

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 14-parameter tool with an output schema and rich annotations, the description covers purpose, the cost breakdown, the estimate caveat, caller-set duty/VAT defaults, the pricing model, and the routing alternative. Nothing an agent needs to invoke 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?

Schema description coverage is 100%, so the baseline is 3. The description restates the duty/VAT default pitfall that already appears in the schema, and its note that make/model/year/mileage unlock the margin calculation is also already in the parameter descriptions. It frames the inputs as a cost pipeline but adds little syntax or meaning the schema does not already supply.

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+output: it converts a GBP price and adds shipping, duty, import VAT, VRT, NOx levy and a buffer to produce a landed cost in EUR, plus an optional margin vs the Irish median. It also names the sibling it is not (estimate_irish_vrt). An agent can distinguish it from every listed sibling without opening a 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?

Explicit trigger ("Use to judge a UK import"), an explicit condition for the secondary margin output (provide make, model, year, mileage), and an explicit alternative with the condition that selects it (estimate_irish_vrt for an already Irish-valued vehicle needing only VRT/NOx). Also states the pricing condition for calling at all.

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, non-open-world). The description adds non-obvious operational context: each call costs 0.01 USDC via x402 and no-data results are free, which materially affects how an agent should budget and retry calls. It does not describe return format or pagination, but an output schema exists, so that omission is minor.

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 use case, then the routing alternative, then the cost caveat. Every sentence carries decision-relevant information and nothing is repeated from the schema or annotations.

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

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

With only two required string parameters, full schema coverage, an output schema covering return values, and annotations covering the safety profile, the description fills the remaining gaps — scope, sibling routing, and cost model. Nothing an agent needs to invoke this 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?

Schema description coverage is 100% for both parameters (make, model, both case-insensitive with defaults and examples), so the schema carries the burden and the baseline is 3. The description's mention of model-year and fuel-type breakdowns describes output dimensions rather than the inputs, adding no extra meaning about how to supply make/model.

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 — a market overview for one model in the Irish used market — and enumerates exactly what is returned (listing count, price range, median, and breakdowns by model year and fuel type). It also explicitly names the sibling it is not, price_check, so an agent can distinguish the two without inspecting schemas.

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 stated explicitly: use this tool for a model-level overview, and use price_check instead when valuing one specific car with year, mileage, fuel type and optional transmission. Both the when and the when-not, along with the alternative, are present.

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 read-only/idempotent/openWorld, but the description adds material behavior the annotations cannot convey: the 404 + no-charge path when fewer than 5 comparables exist, the per-call price (0.005 USDC via x402), and that no-data results are free. Cost and failure semantics are precisely the things an agent needs before invoking a paid tool.

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

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

Four compact sentences, front-loaded with purpose, then output shape, failure behavior, alternatives, and cost. No filler or restatement of the title; every clause carries operative 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?

With an output schema present, the description need not explain return values, and it correctly omits them while covering the gaps that matter: pricing, error/no-data behavior, comparable cohort definition, and sibling routing. Nothing an agent needs to invoke this 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?

Schema description coverage is 100%, so the baseline is 3, but the description goes further by explaining how inputs drive the match: same make/model/fuel, transmission 'if given' (confirming it is optional despite appearing in the properties list), and tolerance of within 1 year and 30,000 km. That matching-tolerance semantics is not derivable from the schema alone.

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 ('value a specific car') plus the exact output statistics (median, mean, quartiles, range) and the comparable-matching rule. It explicitly distinguishes itself from the sibling tools market_stats and analyze_listing by name, so an agent can route 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?

Gives explicit alternatives with selecting conditions: 'Use market_stats instead for a broad make/model overview, or analyze_listing when you already have a listing_id.' This is exactly when-to-use-this vs when-to-use-that guidance rather than implied 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 cover the safety profile (readOnly, idempotent, non-destructive), so the description correctly spends its words elsewhere: per-call cost of 0.01 USDC via x402, free no-data results, and a data-quality caveat that small counties may have few listings. It stops short of describing pagination or result-size behavior, so not 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 dense sentences: purpose first, routing alternative second, operational caveats last. No filler and nothing buried mid-paragraph.

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 values need no explanation. With cost, data-sparsity caveat, and sibling routing all covered alongside annotations that carry the safety profile, an agent has everything needed 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% so the baseline is 3, but the description adds real meaning the schema obscures: it explains that a model, a make, or no filter at all are all valid queries ('or all cars'), which counteracts the schema's misleading Toyota/Corolla defaults, and it notes model should be paired with make.

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 analytical verb and resource: where a model/make/all cars is cheapest or dearest across Irish counties, normalized against the national median. That scope is distinct from sibling market_stats, so an agent can route without opening either 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?

Opens with the use case and names the exclusion explicitly: 'Use market_stats instead when county comparison is not needed.' The when-to-use condition and the named alternative are both present.

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