AB[500] research and bounties

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld). The description adds interpretive context the annotations cannot: prices are 'indexed' lowest asks, the comparison is an affordability signal rather than a valuation/forecast, and no trading occurs. It does not describe refresh cadence, pagination, or result shape, but an output schema exists for that.

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 the core operation front-loaded, followed by scope limits and interpretation caveats. 'No trading.' is terse but relevant; there is no filler or restated boilerplate.

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 2-param read tool with annotations and an output schema, the description covers purpose and interpretive limits adequately. Gaps remain on the origin of slugs (project slugs from search_projects vs. other identifiers) and the role of budget_eth, both of which an agent needs 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 0%, so the description must carry parameter meaning. It only implies the 'up to ten' bound (already in the schema via maxItems: 10) and says nothing about budget_eth — whether it filters, caps, or merely annotates results — nor where slugs come from.

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 (compare), resource (project lowest asking prices), unit (ETH/WETH), and scope cap (up to ten projects). No sibling tool performs price comparison, so an agent can place it immediately without needing an explicit alternative named.

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 fences off misuse ('Lowest ask is an affordability comparison, not intrinsic value or a return forecast. No trading.'), which is genuine when-not guidance. However it never states when to reach for this tool versus get_project or search_projects for single-project or discovery queries, leaving the 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 declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds one genuine behavioral fact — it returns browser/app handoffs rather than performing installation or execution — but says nothing about auth, rate limits, or result shape.

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, zero filler, with the core action front-loaded and the scope caveat immediately after. Nothing could be cut without losing 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?

An output schema exists, so return values need not be described. But for a tool with an undocumented query parameter and no sibling differentiation, the description leaves the agent without enough to decide when to call it or how to phrase the query.

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 is one parameter (query) with 0% schema description coverage, and the description never mentions searching, filtering, or what the query string accepts. It falls back on 'Find curated ... capabilities' which only loosely implies a search term, so the undocumented parameter is not compensated for.

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 (Find) and resource (curated AB5D capabilities and apps on abx.io), and the second sentence bounds the result type. However, 'AB5D capabilities' is unexplained jargon and the description does nothing to distinguish this from the art/project-oriented siblings, so an agent must infer the domain.

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 implies its role as a discovery/lookup tool and explicitly rules out installation or execution, which is a useful boundary. But there is no positive when-to-use guidance, no prerequisites, and no named alternative among the many sibling tools.

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

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

With annotations already covering the safety profile (readOnly, idempotent, non-destructive), the description still adds substantial behavioral context: linked owner wallets are excluded, ranking stops before a 50% asking-price jump, prices are unverified, and gas is excluded. These algorithmic and data-provenance invariants are exactly what an agent needs and cannot get from 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 dense sentences with no filler; the ranking rule is front-loaded and the caveats are packed into the tail. Every clause carries 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?

An output schema exists, so return structure need not be explained, and the ranking/caveat text is strong. However, the required 'budget' parameter and pagination parameters are left semantically opaque, and the core 'AB[500]' concept is never defined, leaving gaps for an agent with no prior context.

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

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

Schema description coverage is only 25% — just the 'profile' parameter is documented — so the description carries the burden but explains none of budget, limit, or offset semantics (e.g., whether budget is total or per-item, or the currency/units). The phrase 'each row is a budget alternative' hints at per-row budgeting, but that is too faint to compensate for the coverage 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?

States a specific verb and object ('Rank indexed AB[500] asks by ETH per added percentage point of edition ownership'), which clearly separates it from sibling tools like compare_project_prices or search_projects. It loses a point because 'AB[500]' and 'edition ownership' remain domain jargon that an unfamiliar agent cannot decode from the text alone.

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 closing clause 'each row is a budget alternative, not a basket' gives useful interpretive guidance on how to consume results, but the description never states when to pick this tool over siblings such as compare_project_prices, nor any prerequisites or exclusions for the call itself.

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 real value beyond that by enumerating operations it will NOT perform (login, project registration, signing, deploy, credential creation) and by identifying the target as a public descriptor, implying no authentication is required.

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: the positive purpose is front-loaded, followed by the negative scope. Every clause earns its place by narrowing what the agent should expect; there is no filler.

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

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

With an output schema present, the description need not explain return values, and the annotations cover safety. What it supplies (public, read-only, no side effects) is sufficient for a zero-parameter descriptor lookup; only the absence of any explicit tie-in to sibling tooling keeps it from being fully complete.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. Nothing in the description misleads about inputs, and the empty, closed schema (additionalProperties: false) is consistent with the stated read-only documentation behavior.

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 ("the documented ABX public service descriptor"), which is precise enough for an agent to know this returns documentation rather than data. It does not name or contrast with any sibling tool, and no sibling clearly overlaps, so 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 description implies usage (consult this to learn about the ABX public service) and the exclusion list implicitly tells the agent this is not the tool for actually doing ABX operations. However, it never states explicitly when to reach for this tool or which sibling to prefer for related needs, 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 declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description does add real context beyond them — collector rows are paginated and can reach thousands of entries for Raster-indexed oeuvres — which explains data volume and the need for limit/offset, but it says nothing about auth requirements, ordering, or end-of-results 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 sentences, front-loaded with the verb and identifying key, and the second sentence carries non-redundant pagination rationale. No filler and nothing buried.

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

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

With no output schema and thin schema coverage, the description should at least sketch what a 'collector TDH register' row contains and whether results are ordered; it only says rows are paginated addresses. Adequate to call the tool correctly, but the return contract remains largely unspecified.

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 only 33%: 'slug' is documented in-schema while 'limit' and 'offset' are not. The description's pagination sentence signals that these control paging, partially compensating, but it never states defaults, maximums, or what happens when offset exceeds the row count.

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 ('Get one artist-specific collector TDH register by AB5D artist slug'), and the 'one ... by slug' phrasing implicitly contrasts with the list variant. It does not explicitly distinguish itself from siblings like get_artist_otdh or list_artist_collector_tdh, so it falls short of a 5.

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 only implied: the 'one register by slug' framing suggests single-artist lookup while pagination suggests browsing large sets, but no alternative tool is named and no when-not-to-use condition is given. An agent must infer the get-vs-list split from the sibling names alone.

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, non-destructive, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing behavioral beyond that (no auth, rate-limit, or freshness caveats); 'snapshot metadata' hints at point-in-time data but is not explained.

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 front-loaded sentence with no filler; the resource and the lookup key are both established immediately. Every clause (returned metrics, key format) carries 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 tool with full annotation coverage, the definition is nearly sufficient; enumerating the returned metrics partly compensates for the absence of an output schema. The remaining gap is the lack of any sibling differentiation or note on what 'oTDH' means, which get_otdh_methodology presumably covers.

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% for the single 'slug' parameter, and the schema already documents it as an AB5D artist slug with an example. The description only restates 'by AB5D artist slug', adding no format or scope detail 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?

The description gives a specific verb ('Get') and resource ('one artist's oTDH') and enumerates the returned metrics, so its purpose is unambiguous. It stops short of distinguishing itself from adjacent siblings such as get_artist_collector_tdh or list_artist_otdh, only implying the single-artist scope via 'one artist's'.

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 rather than stated: 'one artist's' suggests this is the singular lookup counterpart to list_artist_otdh, but no alternative is named and no when-to-use or when-not-to-use condition is given. An agent must infer routing from the name pattern alone.

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, openWorld behavior, so the bar is lower. The description adds genuine return-context: render plus indexed public owner with timestamp, and explicitly bounds scope by saying transfer history is excluded. It stops short of describing freshness/staleness of the indexed owner or 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 tight sentences with the primary action front-loaded and the scope limitation trailing. Nothing is padded, though 'through the existing artwork API' is internal implementation detail that occupies space an agent cannot act on.

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 not be re-explained, and the description does add the useful negative scope. However, for a two-parameter lookup with zero schema descriptions, it omits what slug/edition resolve to and what happens when no minted edition matches.

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 0%, so the description carries the burden for both required parameters, yet it never explains what 'slug' identifies (project, artist, or artwork) or what 'edition' indexes. 'Minted edition' hints at the edition parameter's meaning but leaves slug and the not-minted/error case unaddressed.

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 (a minted edition) and scopes it with 'through the existing artwork API.' The parenthetical 'not full transfer history' sharpens what the lookup covers, though it never names or contrasts a sibling such as prepare_artwork_display or get_collection_holdings.

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 only implied by 'look up a minted edition.' There is no statement of when to reach for this versus the ~20 sibling tools, no prerequisites, and no exclusions beyond the transfer-history caveat.

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, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: it discloses what the response contains (status, operational routes) and imposes a conditional workflow gate on the returned status. It stops short of covering error behavior for a missing or malformed id.

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 zero filler; the retrieval scope is front-loaded and the operational caveat follows immediately. 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?

With no output schema, the description carries the burden of describing returns, and it does say the result includes status and operational routes. Combined with read-only annotations and a fully documented single parameter, an agent has enough to call this correctly; only failure/missing-id behavior is unaddressed.

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 the single parameter, so the schema already documents task_id with an example. The description's phrase 'by identifier' adds no syntax, format, or constraint detail beyond what the schema provides, which is the expected baseline.

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

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

The description gives a specific verb and resource ('Get one AB5D bounty task by identifier') and scopes it to a single record, which implicitly separates it from list_open_bounties. It also names the returned content (current status, operational routes), but it never names a sibling explicitly for contrast, so it lands just shy of a 5.

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 only guidance is a post-retrieval rule ('Do not begin work unless the returned status is open') plus the schema hint that the id comes from list_open_bounties. There is no explicit statement of when to call this versus list_open_bounties or get_project, so usage must be inferred.

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 the safe-read profile (readOnly, idempotent, non-destructive). The description adds genuinely useful behavioral context beyond that: data is served 'from the existing cache' (implying possible staleness) and 'Reports pending data honestly' (implying some fields may be pending). These caveats are not in 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?

Two short, front-loaded sentences with the resource named first. 'Reports pending data honestly' is slightly editorial and could be tightened, but there is no filler bloat.

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 not be described, and annotations cover the safety profile. However, the description is thin for a tool with three fully undocumented parameters and no usage routing, leaving meaningful gaps.

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 0%, so the description carries the full burden of explaining limit, query, and offset. It mentions none of them, leaving all three parameters undocumented in both schema and prose, which is a real gap for a searchable/paginated endpoint.

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 ('Read') and names concrete resources ('AB5D institutional holdings and public credit lines'), plus scope ('from the existing cache'). It is clearer than a tautology, but it never distinguishes itself from related siblings such as get_donor_credits or search_public_collectors, and 'AB5D' is undefined jargon.

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?

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. Siblings like get_donor_credits and search_public_collectors overlap conceptually, yet the description offers nothing to route the agent between them.

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), so the bar is lower. The description nonetheless adds two real behavioral facts beyond the annotations: only 'published' records are returned, and absence of a credit must be treated as unknown rather than as evidence of no donor — a meaningful guardrail against hallucinated attribution.

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, front-loaded with the purpose and followed by the interpretive caveat. Every clause carries information; nothing is padded or restated from 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 values need not be explained, and annotations cover safety. However, with 0% parameter description coverage and no guidance on empty-query behavior or pagination expectations, the description is only just adequate for an agent to call this tool 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 0% and there are 3 parameters, so the description carries the full burden — and it says nothing about limit, offset, or what 'query' actually matches (donor names? accession numbers?). The mention of 'accession and donor credit records' only faintly implies the query domain; pagination semantics and the value of omitting query are left entirely undocumented.

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 and resource: 'Find published accession and donor credit records.' It is clear what the tool retrieves and that results are scoped to published records, but it does not distinguish itself from any sibling (e.g. search_artists, list_dossiers), leaving the agent to infer the boundary from the resource name alone.

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?

There is no guidance on when to use this tool versus the many sibling list_/search_/get_ tools, nor any stated prerequisites. The second sentence is a caveat about interpreting absence, not a usage rule, so an agent gets no routing help 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 readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds real value by disclosing the response shape (subtitle, markdown prose, identity, works, images, bibliography with source URLs) and the CC0 licensing of the prose, which the annotations do not convey.

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

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

Two sentences, front-loaded with the action and key requirement, then a tight enumeration of returned content. No filler, no repetition of structured fields, and the licensing note is short and relevant.

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

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

With no output schema, the description carries the burden of describing the return payload and does so thoroughly. It omits edge cases such as behavior for an unknown slug or payload size limits, but for a single-entity read-only fetch it is essentially complete.

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

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

Schema coverage is 100% and the single 'slug' parameter is fully documented in the schema, including an example and its origin (list_dossiers/search_artists). The description only restates 'by slug' and adds no format or validation detail beyond the structured field, so 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?

States a specific verb and resource ('Get one artist's full structured biography by slug') and enumerates the exact contents returned. The singular 'one artist's ... by slug' clearly separates it from list_dossiers and search_artists without needing to name them.

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 rather than stated: 'by slug' signals the key requirement and 'one artist' implies fetching a single record after a listing. However, no sibling is named and there is no explicit when-to-use/when-not guidance, leaving the agent to infer the lookup-after-search flow.

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, destructiveHint=false and closed-world behavior, so the safety profile is covered. The description adds useful scope information (that the response includes formulas, limitations, and snapshot metadata), but says nothing about authentication, rate limits, or snapshot dating semantics beyond naming the field.

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 front-loaded sentence with the action and subject leading, followed by an enumerated list of contents. It is dense but every clause maps to a distinct returned artifact; only the run-on enumeration slightly hurts scannability.

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

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

With no parameters and no output schema, the description compensates by enumerating the returned artifacts (definition, formulas, coverage, limitations, URL, metadata). Combined with annotations that cover the safety profile, an agent has enough to call and interpret this tool, though it lacks guidance on when to reach for 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 tool takes zero parameters, so there is no parameter semantics to document; baseline 4 applies. The description correctly implies no inputs are required by describing only the returned content.

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 ('Get') and a precise resource: the methodology for AB5D's artist-level OTDH metric, enumerating the exact contents (definition, formulas, coverage, limitations, discussion URL, snapshot metadata). This clearly distinguishes it from sibling tools like get_artist_otdh and list_artist_otdh, which return data rather than the metric's methodology.

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 never says when to call this versus get_artist_otdh or the list variants, nor that it is a prerequisite for interpreting those metrics. Usage is only implied by the name and the word 'methodology'. No exclusions or alternatives are offered.

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 non-open-world behavior, so the safety profile is fully covered. The description adds the scope of linked resources returned, which is useful, but says nothing about not-found handling or whether 'canonical' filters out non-canonical records.

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 verb and resource first and zero padding. Slightly compressed by the ambiguous term 'canonical', which is never defined.

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-identifier read tool with an output schema handling return values and annotations handling safety, the description covers purpose and the linked-resource scope adequately. It would be complete with a note on what 'canonical' excludes and the failure mode for an unknown slug.

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 0%, so the burden falls on the description, which never mentions the slug parameter at all. The parameter name is self-descriptive and the schema supplies a pattern, so the gap is mild rather than severe, but no added meaning is provided.

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

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

States a specific verb (Read) and resource (one canonical project) and enumerates the linked entities returned (essay, dossiers, license). This separates it from list/search siblings like search_projects and list_dossiers, though 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?

The phrase 'one canonical project' implies a single-record fetch by identifier and contrasts implicitly with the search/list siblings, but there is no explicit statement of when to use this versus search_projects or get_artwork. Usage is implied rather than stated.

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

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

Annotations already cover readOnly, idempotent, non-destructive and closed-world, so the safety burden is lifted. The description still adds real value by disclosing the fixed record count (308) and the shape of each record (metric label, route, data URL, verified/pending source status), which tells the agent what it will get back. Pagination and rate-limit behavior remain 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?

A single front-loaded sentence with no filler: verb, resource, count, and returned fields in one pass. Every clause carries 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 no output schema and zero parameters, the description carries the return-value burden, and it does so by enumerating the fields in each record. Annotations supply the safety profile. Only the absence of pagination/ordering behavior keeps it short of complete.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4 and there is nothing for the description to disambiguate. No argument syntax is needed or missing.

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 ('List') and resource ('artist-specific collector TDH dashboard records'), with a scope qualifier ('all 308'). It does not explicitly name the singular sibling get_artist_collector_tdh or list_artist_otdh, so differentiation is implied by the list/get prefix rather than stated.

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 only implied by the verb and scope: an agent can infer this is the bulk-enumeration counterpart to get_artist_collector_tdh, but the description never says when to prefer this over the singular getter or over list_artist_otdh. No exclusions or prerequisites are given.

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, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely useful behavioral context the annotations lack: what oTDH measures, its 1,000 scale, and that it is price-independent and neutral to edition size, project count and release date. It stops short of stating the sort direction or pagination 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 sentences, front-loaded with the action and scope; the second sentence defines oTDH, which earns its place by making the ranking interpretable. Slightly heavy on metric definition for a list operation, but nothing 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?

With no output schema and no annotations covering return shape, the description should describe what a record contains (rank, artist, score) and whether ordering is descending. It conveys the metric's scale but not the record structure, leaving a real gap for a list 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 0%, so the description must carry the load. The phrase 'a limited leading subset' does add meaning to `limit` beyond the bare integer/min/max/default in the schema, implying it selects the top-ranked entries rather than an arbitrary page. It still omits the default of 25 and the 1-308 bounds behavior.

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 (List) and resource (ranked oTDH records) plus scope (all 308 AB[500] artists or a limited leading subset), which is concrete and unambiguous. It never names the sibling get_artist_otdh or list_artist_collector_tdh, so the agent must infer the single-vs-multi distinction from scope wording alone.

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

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

No when-to-use guidance is offered: nothing says when to prefer this list over get_artist_otdh, list_artist_collector_tdh, or get_otdh_methodology. The description defines the metric but leaves routing to the agent.

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 safety is covered. The description adds a real behavioral constraint beyond them: only *published* dossiers are returned, plus the shape of each record (name, slug, subtitle, editions, tier, updated date). It omits pagination or ordering behavior for what could be a large list.

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, front-loaded with the scope ("every published") and followed by the use case. 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 no output schema, enumerating the returned fields is what makes this complete, and the annotations carry the safety profile. The only gap is that a "list every" tool gives no hint about pagination, result size, or ordering.

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, so the baseline of 4 applies; there is nothing for the description to disambiguate. The listed return fields are a bonus, not a parameter explanation.

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 (List) plus resource (published AB[500] artist dossiers) and enumerates the returned fields, so an agent immediately knows this is a bulk enumeration rather than a single-record fetch. It is cleanly separable from the sibling get_dossier, which returns one dossier.

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 it to see which artists have a published biography" gives a clear triggering context, so the agent knows when to reach for it. It stops short of naming alternatives or exclusions (e.g. use get_dossier for full detail), so it does not reach the 5 threshold.

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 genuine behavioral content beyond that: it confirms only currently-open offers are returned and enumerates the payload fields (reward, eligibility, claim/submission routes, protocol, acceptance command), partially compensating for the absent 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?

Two tight sentences, the scope constraint is front-loaded and the returned-field list follows. Minor overlap between 'currently open for claim' and 'current offers' is negligible and does not dilute the definition.

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

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

With no output schema, the description carries the burden of describing return content and does so by naming the six fields a caller will receive, plus the scope of the result set. It is complete enough to invoke correctly, though it does not describe ordering, volume, or pagination for an unfiltered list.

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, so the baseline is 4; there is nothing for the description to disambiguate. It correctly does not waste space restating a nonexistent input contract.

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 (list) and resource (AB5D bounties) with a scope qualifier (currently open for claim), and enumerates the fields returned. It implicitly distinguishes itself from the singular get_bounty sibling by emphasizing the 'open for claim' filter, though it never names an alternative 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?

'Only returned tasks are current offers' implies the result set is restricted to actionable bounties, giving an agent a general sense of when to reach for it. However, there is no explicit when-to-use vs get_bounty guidance and no exclusions or prerequisites 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 and non-destructive, so the safety profile is covered. The description adds meaningful context beyond that: despite the action verb 'prepare', it explicitly will not connect to a TV or start playback, clarifying the scope of the side effect. It stops short of describing what the 'Cast workflow' actually entails.

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, zero filler, with the positive purpose front-loaded and the limiting boundary immediately after. Nothing 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?

An output schema exists, so return values need not be explained, and annotations cover safety. That leaves the poorly documented parameters (0% schema coverage) as the main gap, which the description does not fill, making it only minimally complete for a tool with an ambiguous 'prepare' action.

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 0%, so the description carries the full burden of explaining the three parameters. It never explains slug, the one/series 'mode' enum, or the 'edition' integer; the only hint is the phrase 'artwork or series', which loosely maps to mode. This leaves two of three parameters undocumented anywhere.

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 ('Prepare') and resource ('verified artwork or series display URL and existing mobile Cast workflow'), so the agent knows it produces a URL plus a Cast workflow. It does not differentiate itself from the sibling get_artwork, which is the nearest alternative, so it falls short of a 5.

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?

'Does not connect to a TV or start playback' functions as an explicit when-not boundary, which is useful. However, there is no positive guidance on when to choose this over get_artwork or what prerequisite (a verified artwork) must hold; usage is only 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety and determinism are covered. The description adds the return shape (artists plus slugs), but says nothing about result limits, pagination, or matching semantics for a search that could return many hits.

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 tight sentence-fronted definition: purpose first, then the routing instruction. Every clause earns its place with no filler.

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

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

For a one-parameter search with no output schema, the description covers purpose, input meaning, return content, and next step. The only gap is search behavior such as result count or ranking, which is minor for a tool this simple.

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

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

With one parameter at 100% schema description coverage, the schema already documents 'query' with examples. The description restates 'by name or keyword' without adding syntax, matching behavior, or format detail 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 and resource ('Search AB[500] artist dossiers'), names the lookup keys (name or keyword), and specifies the return (matching artists with their slugs). It is clearly distinguishable from get_dossier and list_dossiers by being the fuzzy-search entry point.

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

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

Gives an explicit precondition and the alternative it feeds: 'Use before get_dossier when you don't know the exact slug.' That is clear routing guidance, though it doesn't mention when to prefer list_dossiers instead, so it stops short of full when/when-not coverage.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that results come back as 'canonical links and native app handoffs', which is useful context about the nature of the response, but it says nothing about pagination behavior, rate limits, or result ordering.

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 the purpose front-loaded and no filler. Nothing in the text is repeated or wasted; it is simply short enough that it omits useful detail rather than padding with noise.

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 explanation is not required, and annotations cover the safety profile. The remaining gaps are the absence of any sibling routing (search_artists vs this tool) and any mention of pagination, which is significant for a search endpoint exposing limit/offset.

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 0%, so all three parameters (query, limit, offset) are undocumented in the schema. The description partially compensates for 'query' by naming the search axes (title, artist), but limit and offset — including the 50-item cap and pagination semantics — are entirely unaddressed in both places.

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 ('Find'), a named resource ('AB[500] artworks and series'), and the search axes ('by title or artist'). However, the tool is named search_projects while the description talks about artworks and series, and the sibling list contains search_artists and get_artwork without any differentiation of scope, leaving some ambiguity about what a 'project' is here.

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 never says when to reach for this tool instead of search_artists, get_artwork, or get_project, nor any exclusion conditions. Only implicit usage is conveyed by 'Find ... by title or artist'; no routing guidance is offered.

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, closed-world, and non-destructive behavior. The description adds meaningful context about data scope: only published collectors, no private account access, no inferred identity, and wallet arrays omitted. This exceeds annotation coverage, so 4.

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

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

Two sentences, front-loaded with purpose and followed by a concise constraint note. No wasted words, and the structure is clear. Score 4.

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

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

The tool has three optional parameters, an output schema, and rich annotations, yet the description omits any parameter guidance or usage context. While privacy scope is covered, the lack of input semantics leaves the definition incomplete for correct invocation. Score 2.

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 0%, and the description does not mention limit, query, or offset. With three undocumented parameters, the description fails to compensate for the schema gap, making it impossible to know parameter meaning from the text. Score 1.

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 ('Search the already-published collector register'), which distinguishes it from sibling search tools for artists and projects. However, it doesn't explicitly name an alternative or differentiate from other search_* siblings, so a 4 rather than 5.

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

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

No guidance on when to use this tool versus alternatives, nor any prerequisites. The boundary 'No private account access' is a constraint, not usage guidance. Implied usage only, so 2.

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