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

With no annotations present, the description carries the full burden and does so thoroughly: it discloses that continuation pages are not auto-fetched, arrays are truncated at 100 rows/256 KiB with reports, oversized records are refused, fields may be null, and wire types remain JSON-encoded strings. This goes far beyond a basic read description.

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

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

The description is front-loaded with the purpose and then provides dense, useful caveats. It is slightly verbose with boilerplate such as 'Other declared filters are forwarded as supplied,' which is confusing given the one-parameter schema, and it has a missing period after 'Makes one logical GET request.'

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 having no output schema and no annotations, the description covers nullability, wire-format behavior, request nature, pagination, local limits, truncation reporting, refusal behavior, and policy/upstream constraints. For a one-parameter read-only endpoint, an agent has enough context to call correctly and interpret results safely.

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

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

The schema only exposes username with minLength 1, and the description calls it 'explicit username' and notes that required inputs reflect tool policy/upstream requirements. It does not add much semantic detail beyond the parameter name, but for a single self-describing parameter this is adequate.

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

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

The description opens with a specific verb and resource: 'Read the existing battle queue records for an explicit username.' It also clarifies what it is not ('does not join a queue or submit a team'), distinguishing it from battle-queue mutation tools and from siblings like battle_status or battle_result.

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

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

The description gives clear context: use this to read queue records for a particular username, not to perform mutations. It explicitly excludes queue-joining and team-submission behavior. It does not name a specific alternative sibling, but the negative instruction is enough to route an agent correctly.

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 no annotations, the description carries the full burden and does disclose meaningful behaviors: original wire types, JSON-encoded strings, unknown-ID error strings, oversized-result refusal, one logical GET request, no continuation-page auto-fetching, and local array limits. Some boilerplate is generic and ambiguous, but overall transparency is strong.

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

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

The description is over-long and contains repetitive statements about oversized results, vague boilerplate about declared filters, and grammatical issues. The key information is buried under generic sentences that do not clearly apply to this single-parameter tool.

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

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

For a tool with no output schema and no annotations, the description covers many important aspects: read behavior, possible ID variants, error handling, request method, pagination stance, and response-size limits. It remains somewhat unclear about the exact successful response shape, but it is reasonably complete for a simple endpoint.

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 explain the sole 'id' parameter. It does: the id is a queue transaction ID, and either the captured or opponent's queue ID can return the same battle. That adds real meaning beyond the schema's type/minLength, though no format example is given.

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 opening sentence 'Read a battle result by explicit queue transaction ID' clearly names a specific verb, resource, and key. The follow-up sentence about captured opponent queue IDs adds useful nuance but is grammatically awkward, and no sibling tool is named for differentiation.

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

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

The description states that an explicit queue transaction ID is required, but gives no guidance on when to choose this tool over siblings like battle_queue or battle_status. Statements about 'required inputs reflect tool policy' and filters being forwarded are vague and do not help an agent decide.

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

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

With no annotations, the description carries the full burden and delivers substantial behavioral detail: unknown IDs return HTTP 200 error strings, only one logical GET is made, no continuation pages are auto-fetched, array responses are locally limited to 100 rows and 256 KiB, truncation is reported, and oversized records are refused. This is exceptionally transparent.

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 main purpose is front-loaded and most sentences add behavioral value. However, boilerplate phrases like 'Required inputs reflect tool policy...' and 'Other declared filters are forwarded as supplied...' are vague and largely irrelevant for a single-parameter schema.

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

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

For a single-ID lookup with no output schema and no annotations, the description covers ID sourcing, error semantics, request behavior, and local limits. It partially describes return data by mentioning team and settings as JSON-encoded strings, but does not fully characterize the response shape, which leaves some uncertainty for the agent.

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

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

The single parameter is described as an 'explicit queue transaction ID' obtained from battle_queue, which adds meaning beyond the bare schema. Since schema description coverage is 0%, this semantic clarification is important; it could further specify format or expected length, but one well-contextualized parameter is largely covered.

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

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

The description opens with 'Read battle status by explicit queue transaction ID,' naming a specific verb, resource, and lookup key. It further points to battle_queue as the source of the ID, which differentiates it from the many sibling lookup and battle-related tools.

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

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

It gives explicit guidance to obtain the ID from battle_queue and explains how unknown IDs are handled (HTTP 200 with an error string). It does not explicitly contrast with battle_result or other siblings, but the ID-source instruction provides clear practical usage 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?

With no annotations provided, the description carries the full burden and does an excellent job. It discloses caching behavior, response format (bare array, JSON string counts), pagination behavior, local row/size limits, truncation reporting, and refusal of oversized records. This is far beyond what annotations would typically provide.

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

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

The description is dense but well-organized, front-loading the core purpose and then covering behavioral details. Every sentence adds value, though the length is slightly high for a zero-parameter tool. It could be trimmed slightly without losing essential 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 zero-parameter, no-output-schema tool, the description is remarkably complete. It covers what the tool does, how it behaves, limits, truncation, and refusal behavior. An agent has everything needed to call it correctly and interpret the response.

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

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

The schema has zero parameters, so there are no parameter semantics to document. The description explains that required inputs reflect tool policy and upstream requirements, and that other declared filters are forwarded as supplied. This is a baseline 4 for a zero-parameter tool, with the description adding useful context about how inputs are handled.

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

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

The description clearly states the tool reads public card gold-reward counts, which is a specific verb and resource. It distinguishes itself from siblings by focusing on gold-reward counts, though it doesn't explicitly name a sibling alternative.

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

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

The description provides clear context: it reads public data, uses a bounded cache, makes one logical GET request, and does not auto-fetch continuation pages. It doesn't explicitly state when to use this tool versus alternatives, but the scope is clear enough for an agent to select it appropriately.

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 no annotations at all, the description carries the full burden, and it discloses extensively: projection, caching (60s page cache, invalidation), memory guards (128 MiB heap, 358 MiB RSS), timeouts, retry behavior, handling of missing/null fields, filter semantics, and upstream response limitations. This goes far beyond what any annotation set would typically provide.

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

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

The description is a single dense wall of text, not front-loaded; the central purpose appears only after several sentences about include_plot_references. Many operational details (memory sampling cadence, RSS ceiling rationale, wire type minutiae) are likely unnecessary for an agent to select and invoke the tool, making it overlong and poorly structured.

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

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

Given a 16-parameter tool with no output schema and zero schema coverage, the description is exceptionally complete: it covers response fields, absence semantics, pagination absence, caching, request counts, and error/edge behaviors. There is no obvious missing information an agent would need to 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 0%, and the description compensates richly. It explains include_plot_references, staked enums ('staked=no selects explicitly unstaked cards (not cooling or pending)'), color normalization, min_land_base_pp semantics, and cursor/limit behavior. It effectively documents nearly all 16 parameters with actionable meaning.

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

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

The description clearly identifies the resource and operation: 'Stream the projected collection returned by GET /cards/collection/{username}'. It also adds a differentiator with 'This is not complete holdings discovery', which helps distinguish it from holdings-oriented tools. However, it does not explicitly name an alternative sibling or contrast with cards_get_details, cards_find, or player_inventory, so it falls just 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?

The description focuses heavily on internal behavior (memory, caching, wire types) rather than when to choose this tool over siblings. The only usage guidance is 'This is not complete holdings discovery', which hints at exclusions but does not state when to use this versus other card collection or inventory tools, nor any prerequisites or non-use cases.

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 no annotations, the description carries the full burden and does so thoroughly. It discloses encoding errors, return fields, semantics of player ownership, limits (100-row, 256 KB), and caching behavior. No contradictions with annotations (none present).

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

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

The description is dense but every sentence adds value, front-loading the purpose, then encoding rules, then fields, then semantics, then limits. No redundant or filler 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?

Given one parameter, no output schema, and no annotations, the description covers all necessary aspects: purpose, encoding, expected fields, behavioral constraints, and caching. An agent can call it correctly without additional information.

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%, but the description fully explains the single 'ids' parameter: comma-separated UIDs, invalid encodings, and what constitutes a valid request. It adds substantial meaning beyond the bare schema.

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

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

The description clearly states it looks up per-instance card records via a specific endpoint, distinguishing it from definition routes and other card-related siblings. It specifies the resource and scope precisely.

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

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

Provides clear context on when to use (per-instance records with BCX) and implicitly when not to (definition routes), but does not name specific alternative tools. The exclusion of definition routes is explicit, though no sibling is suggested.

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 no annotations, the description carries the full behavioral disclosure burden and does so exceptionally well. It reveals the server-side size-based refusal, that the refusal is this server's choice rather than an upstream rule, 24-hour caching, provenance reporting, and the absence of BCX/donor/account-attribution 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?

The description is long but densely informative, and nearly every sentence contributes behavioral or exclusionary context that the schema and annotations do not provide. Some redundancy exists around the ownership-data point, but the front-loaded purpose and structured flow keep it usable.

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

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

Given no annotations and no output schema, the description is unusually complete: it states the result fields, the filtering requirement, the refusal behavior, caching, provenance, and what the tool intentionally does not return. An agent has enough context to call it correctly and to set expectations about the response.

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 explain what 'type' means, and it does: it is a real upstream filter, a concrete example (type=Summoner) is given, and omitting it leads to refusal. It stops short of enumerating valid type values, but the semantic and consequence of the parameter are clearly conveyed.

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 first sentence names a specific verb ('List') and resource ('card-definition rows... GET /cards/get_details'), making the core action clear. It also notes the tool does not add per-instance ownership data, which partially distinguishes it from inventory-style siblings, though it never names a specific sibling.

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

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

The description gives explicit usage context: the unfiltered route exceeds the server's 256 KB result bound and is refused, so the agent is told to provide 'type' to make a filtered call. It does not name an alternative tool or state when a sibling should be used instead, so it stops short of full routing guidance.

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

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

With no annotations, the description carries full burden and discharges it: it lists returned fields, flags that from_player/to_player are attribution not provenance, notes donor/BCX were absent, and states the 100-row/256 KB bounds and non-caching. No major behavioral trait is left undisclosed.

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?

Dense and front-loaded with purpose and the id caveat; nearly every sentence adds value. Slightly longer than necessary due to repeating the per-instance/non-definition framing and the measured-response detail, but not padded.

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?

Although there is no output schema, the description enumerates the record fields and clarifies the semantics of the route, limits, and cache behavior. For a required-param list endpoint, this is enough for an agent to select and 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 coverage is 0%, so the description must compensate; it does thoroughly for the required id parameter (UID vs numeric, empty-array behavior). However, limit and transfer_types receive no semantic explanation beyond their names/schema types, leaving their expected formats or accepted values ambiguous.

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 an exact verb+resource ('List transfer records... per-instance card UID') and explicitly contrasts with card-definition lookup and enumeration by numeric card_detail_id. This clearly separates it from the many cards_* siblings.

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

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

Provides clear when-to-use context: only for per-instance card UID transfer events, and explicitly warns 'id is a card UID, not a card_detail_id'. It gives when-not conditions but does not name or route to a specific alternative sibling tool, so not a 5.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it discloses the measured response shape, the empty-body failure mode when the parameter is omitted, absence of BCX/donor/attribution fields, 24-hour caching, provenance behavior, and the fact that text is not parsed into card attributes.

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 purpose is front-loaded in the first sentence, and later sentences are informative rather than filler. It is somewhat verbose for a one-parameter read endpoint, with the omission behavior stated twice, but each remaining sentence earns its place.

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

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

For a simple one-parameter endpoint with no output schema, the description covers request requirements, response shape, caching, provenance, and non-derivation behavior. An agent has everything needed to call and interpret 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?

The only parameter is card_detail_id, and schema description coverage is 0%. The description adds the "one" cardinality and the omission consequence, but it does not explain what a card_detail_id represents beyond what the schema name and integer type already imply.

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 the specific verb "Get", the resource "lore object", the endpoint GET /cards/lore, and the required input card_detail_id. This clearly differentiates it from sibling cards_* tools like cards_skins or cards_get_details.

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 explains that card_detail_id is required and must be supplied before making the request, but gives no guidance on when to prefer this tool over alternatives. It does not mention any sibling tools or conditions for choosing this endpoint.

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?

No annotations exist, so the description carries the full burden. It discloses request count, no auto-pagination, forwarding of filters without implied effectiveness, response shape variations (total/total_minted/mints), row and size limits, and refusal behavior for oversized records. This is exceptionally transparent.

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

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

The description is dense but not bloated; the main purpose is front-loaded, and each sentence contributes useful details (limits, behavior, response shape). It could be slightly trimmed but remains efficient for the amount of context it provides.

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

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

For a simple two-parameter read tool with no output schema, the description covers the response shape, limits, truncation reporting, and refusal behavior. An agent has everything needed to call it correctly and interpret results.

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 compensate, but it does not explain what card_detail_id or foil mean or how they map to the upstream contract. It only states that required inputs reflect tool policy and upstream requirements, which is not helpful for understanding parameter semantics.

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

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

States a specific verb ('Read') and resource ('public mint history for one card detail and foil'), and distinguishes itself from the upstream by_date/by_date_edition forms, making its exact scope clear. It is distinct from sibling tools like cards_history or cards_get_details.

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 notes what this tool does not do (auto-fetch continuation pages) and that it binds to card_detail_id plus foil, implying when to use it. However, it does not name specific alternative tools or when-not-to-use conditions, leaving some inference 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?

With no annotations, the description fully carries the burden, and it does so richly: it reveals the measured six-object array shape, the set names, the exact fields and types, the absence of BCX/donor/account fields, the 24-hour caching, provenance behavior, and that rows are returned unchanged. This goes well beyond a generic list description.

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

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

The description is densely informative but not bloated; every sentence provides distinct value: the endpoint, the response shape, the excluded fields, the cache behavior, and the unchanged-return guarantee. The core purpose is front-loaded.

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

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

For a parameterless list endpoint with no output schema, the description is complete enough for an agent to call it correctly and interpret results. It covers what data is returned, what is absent, and how caching/provenance behave. Nothing critical 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 has zero parameters and an empty input schema, so there are no parameter semantics to document. Per the baseline for zero-parameter tools, a score of 4 is appropriate, and the description compensates by detailing the output structure instead.

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

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

The description names a specific verb ('List') and resource ('pack metadata rows returned by GET /cards/pack_data_wax'), and then distinguishes the data from per-card or per-owner data. This makes the tool's purpose unmistakable and differentiates it from siblings like cards_get_details or cards_collection.

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

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

The description provides useful context by stating that this is WAX-bridge mint/burn metadata and not per-card or per-owner data, implying when it should be selected. However, it does not explicitly name alternative tools or state when-not-to-use it, leaving some inference 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?

With no annotations provided, the description carries the full burden and does so extensively: it discloses the bare-array response shape, empty-array validity, caching behavior, single logical GET, no auto-fetch of continuation pages, local row/size limits with truncation reporting, and refusal of oversized records without partial 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?

The description is a dense paragraph that front-loads purpose and response format but includes vague, partially redundant sentences such as 'Required inputs reflect tool policy...' and 'Other declared filters are forwarded as supplied...' when no filters exist in the schema, adding noise without structural headings.

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

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

For a simple one-parameter read tool with no output schema, the description covers the essential return shape, valid empty responses, cache behavior, pagination, and limits. However, it leaves the meaning of 'edition' unexplained and includes irrelevant filter commentary, so it is not 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?

Schema coverage is 0%, so the description must compensate. It only repeats that the tool is 'for one edition' and vaguely says 'Required inputs reflect tool policy as well as measured upstream requirements,' without explaining what an edition is, how to obtain it, or any additional meaning beyond the integer schema.

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

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

The description states a specific action and resource: 'Read the public pack jackpot circulation overview for one edition.' The verb 'Read' and the resource name distinguish it from most sibling tools, though it does not explicitly differentiate it from similar cards_* endpoints like cards_pack_data_wax.

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 usage context (requires an edition, read-only overview) and warns that filters are forwarded without guaranteed effectiveness, but it does not provide explicit when-to-use or when-not-to-use guidance compared to alternatives.

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

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

With no annotations, the description carries the burden, and it does so well by disclosing that responses are cached for 24 hours, provenance includes the route and original fetch time, and rows are returned unchanged with no computed fields. It also gives concrete response-shape details such as a bare array and field names, which is meaningful behavioral context beyond a generic list description.

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

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

The description is front-loaded with the core purpose and then adds supporting behavioral details. The byte count and 'measured public response' phrasing are slightly more specific than necessary, but no sentence is filler and the structure is logical.

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, no-output-schema metadata tool, the description is complete: it states the source route, the response shape and fields, caching behavior, provenance reporting, and what the tool does not do. Nothing essential for selecting or invoking this tool 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 has zero parameters, so the baseline is 4. The description compensates further by documenting the exact fields returned, which is the only semantic information an agent would need for this no-input tool.

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

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

The description opens with a specific verb and resource: 'List the skin rows returned by GET /cards/skins.' It further clarifies scope by naming the exact fields in each row and explicitly noting that no BCX, donor, or account-attribution field is present, which helps distinguish it from player- or account-level tools.

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

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

Usage context is implied rather than explicit: it is a raw metadata list, and the statement that it 'does not calculate availability or prices' signals when not to use it. However, it does not name alternatives or state a concrete condition for choosing this tool over siblings such as player_skins or cards_find.

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 no annotations provided, the description carries the full transparency burden, and it delivers. It exposes non-obvious behavior: a bare call or calls with only username/card_detail_id return an HTTP-200 error rather than a validation error, data and result are JSON-encoded strings that are not parsed twice, player is transaction account attribution (not donor provenance), BCX/donor fields were absent, and the endpoint is not cached. This is far beyond what a typical description does.

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

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

The description is a dense five-sentence paragraph, but every sentence adds a distinct piece of information: purpose, error behavior, response field list, JSON encoding quirk, attribution semantics, absent fields, and caching. The primary requirement (trx_id) is front-loaded in the first sentence. It is not overly verbose for the amount of behavioral detail conveyed, though it could be tightened into a list format for even faster scanning.

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

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

Given there is no output schema and no annotations, the description is notably complete: it enumerates all observed response fields, explains that data/result are JSON strings, clarifies player attribution, warns about absent BCX/donor fields, and states the caching behavior. It does not explain the semantic meaning of the transaction object or the success/error codes in depth, but for a single-object lookup endpoint this is largely sufficient for an agent to 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?

The schema has zero parameter descriptions (0% coverage), so the description must compensate. It clearly identifies trx_id as the only required parameter and implies that username and card_detail_id are optional but cannot substitute for trx_id (using them alone yields an error). However, it never explains the purpose or allowed semantics of username or card_detail_id, leaving an agent to guess what those parameters mean or whether they can be combined with trx_id.

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

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

The description clearly states the tool looks up a transaction object for a real trx_id via a specific endpoint, immediately distinguishing it from cached or aggregate market endpoints. It also adds 'single-transaction event lookup and is not cached as static metadata,' which helps differentiate it from sibling tools. However, it does not explicitly name any sibling tool for comparison, so it falls just short of the highest clarity tier.

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 that the tool should be used when you have a real trx_id and need the raw transaction object, and it warns that username or card_detail_id alone are insufficient (they trigger a missing-trx_id error). There is no explicit guidance on when to prefer a sibling tool (e.g., transaction_lookup or hive_transaction) or when not to use this one, so the usage context is implied rather than explicit.

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 no annotations, the description fully carries the behavioral burden. It discloses: 'One GET, no card metadata fan-out, purchases or layout changes', 'Does not auto-fetch continuation pages', and detailed size limits ('Array responses are locally limited to 100 rows and 256 KiB, with truncation reported... Oversized records are refused without partial fields'). It also mentions preserving fields and asset paths. This is comprehensive and transparent.

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

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

The description is verbose and has redundancies. For example, 'Makes one logical GET request Does not auto-fetch continuation pages' is a run-on, and the oversized object restriction is stated twice ('Oversized objects are refused as a whole' and 'Oversized records are refused without partial fields'). Sentences like 'Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema' are vague and clutter the message. It could be streamlined significantly.

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-parameter tool with no output schema and no annotations, the description covers many operational details (size limits, no fan-out, no auto-fetch) and hints at the response (slots and stickers). However, it lacks explicit parameter descriptions, usage contexts, error behavior, and a clear statement of the return payload structure beyond the examples given. It is adequate but not 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?

Schema coverage is 0% and the description only mentions 'by player and binder reference' — enough to know the parameters are identifiers, but it does not explain the format of 'binderRef' (slug vs ID), constraints, or special requirements. The phrase 'Required inputs reflect tool policy' adds no semantic value. The description fails to compensate for the schema's lack of parameter documentation.

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

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

The description clearly states the verb and resource: 'Read one public collector binder by player and binder reference'. It also limits scope with 'no card metadata fan-out, purchases or layout changes', which distinguishes it from broader tools. However, it does not explicitly name sibling alternatives, so differentiation relies on the reader inferring from the 'one public collector binder' phrasing.

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 explicit guidance on when to use this tool versus siblings like collector_stickers, collector_player, or collector_config. The statement 'Required inputs reflect tool policy as well as measured upstream requirements' is vague and does not help selection. The description implies it is for a single binder read, but no conditions or alternatives 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?

No annotations are present, so the description carries full responsibility for behavioral disclosure. It does this comprehensively: no side effects, one GET request, no auto-fetch of continuation pages, array limits of 100 rows and 256 KiB, truncation reporting, refusal of oversized records, and preservation of relative paths and nullable URLs. This is far beyond a typical read-only description.

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

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

The description is longer than average, but every sentence adds operational value: size expectations, side-effect safety, request behavior, response handling, and limits. It is front-loaded with the core purpose. The only minor flaw is that it could be slightly tightened without losing information, but it remains focused and structured.

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 configuration tool with no output schema, this description is exceptionally complete. It covers what is returned, how much data to expect, the exact request pattern, side-effect guarantees, truncation rules, and preservation expectations. Nothing an agent needs to call and interpret this tool 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?

The tool has zero parameters and the schema is empty with 100% coverage, so there are no parameter meanings to clarify. The description still adds context by explaining that required inputs reflect tool policy and measured upstream requirements, but with no parameters this is inherently a low-effort dimension. A 4 is appropriate because the baseline for zero parameters is high and nothing is 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?

The description opens with a specific verb ('Read') and a clear resource ('complete public collector configuration'), then lists concrete contents: page/slot limits, claim availability, shop metadata, featured accounts and cosmetic definitions. This clearly distinguishes it from sibling collector tools like collector_player, collector_binder and collector_stickers, which all target narrower data.

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

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

It explicitly states that reading this configuration performs no purchase or claim, warns against assuming filters are effective, and notes that oversized configuration is refused as a whole. It also explains that exactly one logical GET is made and continuation pages are not auto-fetched. This gives an agent clear guidance on when and how to use it safely.

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?

No annotations are provided, so the description carries the full behavioral burden. It discloses preservation of original fields and relative asset paths, single logical GET, no auto-pagination, local array limits of 100 rows and 256 KiB, truncation reporting, and refusal of oversized records without partial fields. This is unusually thorough for a one-parameter read endpoint.

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 lead sentence is strong, but the description is redundant: 'One GET' is repeated as 'Makes one logical GET request', and oversized record refusal is stated twice. The sentence about 'Other declared filters' appears to be generic boilerplate because the schema declares only 'player' and no other filters. It could be tightened without losing 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 endpoint with no annotations and no output schema, the description is operationally complete: it covers preservation behavior, pagination, size limits, truncation, and refusal semantics. It leaves the player value format unspecified, but that is more of a parameter-semantics gap than an overall completeness failure.

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

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

The only parameter, 'player', has no schema description and 0% schema coverage. The description only implies the player via 'Read one player' and adds a generic policy note that required inputs 'reflect tool policy as well as measured upstream requirements.' It never states the expected identifier format or meaning, leaving the agent to infer.

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

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

The description opens with a specific verb and resource: 'Read one player collector overview with binder summaries.' It then explicitly scopes the tool with 'One GET, no card metadata fan-out, purchases or layout changes', which distinguishes it from sibling collector/card/market tools. The purpose is clear without relying on the tool 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?

The description gives a clear usage scenario: reading a single player's collector overview with binder summaries. It also states explicit exclusions such as 'no card metadata fan-out, purchases or layout changes' and 'Does not auto-fetch continuation pages.' It does not name a sibling fallback, so it stops short of directly routing to an alternative tool.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses the single GET, local 100-row/256 KiB bounds, lack of continuation-page auto-fetching, truncation reporting, and refusal of oversized records. It is slightly undermined by the unexplained 'observed four rows' comment, but the behavioral disclosure is strong.

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 text is longer than needed and contains jargon and noise ('observed four rows', 'Required inputs reflect tool policy as well as measured upstream requirements', 'Other declared filters are forwarded as supplied' despite no declared filters in the schema). It front-loads the core purpose, but the middle is cluttered and there is a missing period in 'GET request Does not'.

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 tool, the description is reasonably complete about limits and behavior, and it mentions row content (ownership/trade/list flags, cosmetic metadata) and truncation metadata. It lacks an explicit return contract and any alternative routing, and with no output schema the agent still has to infer response shape.

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

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

The schema provides only the parameter name, type, and minLength, and the description does not compensate. It says 'for one player' and that required inputs reflect tool policy, but it does not define whether player is an account name, ID, or any format detail; at 0% schema description coverage, this is a clear gap.

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

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

The opening phrase 'Read the full sticker-list route for one player' gives a specific verb and resource, and the description narrows scope by saying there is no card metadata fan-out, purchases, or layout changes. It does not explicitly contrast a sibling like collector_stickers_tradeable, but the purpose is clear enough to distinguish it from nearby collector_* tools.

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

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

The description implies when it is appropriate by noting 'one GET, no card metadata fan-out, purchases or layout changes' and that the route name does not promise complete holdings. It never names an alternative tool or states a condition for choosing this one over collector_stickers_tradeable or collector_binder, so guidance is inferred rather than explicit.

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 no annotations, the description carries the full burden and does well: it discloses the bounded GET, no auto-paging, 100-row and 256 KiB limits, truncation reporting, and refusal of oversized records. It also clarifies it doesn't list/transfer/buy. This is thorough, though the repeated mentions are redundant and the 'preserve' phrasing is unclear.

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

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

The description is verbose and repetitive. Key limits (bounded GET, no paging, 100 rows/256 KiB) are stated multiple times, and the 'Makes one logical GET request' sentence is repeated. It could be cut by half without losing meaning. The structure is not front-loaded; it mixes critical behavior with redundant caveats.

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

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

Given the tool is a simple read with one parameter and no output schema, the description covers operational constraints well but lacks a clear description of the return format. 'Preserve sticker identities...' hints at fields but doesn't explain the response structure or whether it's JSON, etc. It's adequate but not complete for an agent to fully anticipate the output.

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% and the description adds almost nothing about the 'player' parameter beyond the schema's name/type. It only says 'Required inputs reflect tool policy as well as measured upstream requirements,' which is unhelpful and doesn't specify what the player value should be (e.g., account name, ID). The description fails to compensate for low schema coverage.

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

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

The description clearly states the tool reads one player's tradeable collector stickers, a specific verb+resource. It differentiates itself from the for-sale route and implies distinction from sibling collector_stickers by emphasizing 'tradeable'. However, it doesn't explicitly name sibling tools, so it's not a perfect 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 description gives context that this is a read-only tool and not the for-sale route, but doesn't explicitly say when to use it vs alternatives like collector_stickers or market tools. The phrase 'Required inputs reflect tool policy' is vague and doesn't guide selection. No explicit when/when-not conditions are provided.

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 no annotations provided, the description carries the full burden and does so comprehensively: it discloses no prize claiming, no num_prizes recomputation, single GET request without auto-pagination, forwarding of filters without implied effectiveness, local limits (100 rows/256 KiB) with truncation reporting, and refusal of oversized records. This is exemplary 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?

The description is dense but every sentence carries essential behavioral or scoping information. It opens with purpose then systematically lists caveats, which is logical and front-loaded. Slight verbosity in the filter-forwarding warning could be trimmed, but no redundancy.

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

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

Covers purpose, behavior, and limits well, but does not describe the expected return structure or the meaning of all parameters. With no output schema and no annotations, the agent is left without knowledge of the distribution's fields or the impact of order_by, making it only partially complete for a tool of this complexity.

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

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

Adds meaningful distinction between id and conflict parameters, explaining their differing return contents, and warns that other filters are forwarded without guaranteed effectiveness. However, given 0% schema description coverage, it fails to explain the semantics of lore, mode, and order_by, leaving them under-specified.

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 (player's recorded airdrop distribution) and clearly distinguishes two access modes via id or conflict, noting that conflict returns metadata while id returns only distribution. This sharply differentiates it from sibling conflict_* and player_* tools.

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

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

Provides no explicit guidance on when to choose this tool over alternatives like conflict_seasons or conflict_players, nor does it state exclusions. The mention of 'explicit id or conflict' implies prerequisite context, but the absence of any when/when-not guidance leaves the agent to infer.

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?

No annotations are provided, so the description carries the full burden, and it delivers: it explains sampling semantics, warns not to equate returned UID count with all eligible cards, clarifies that qty/total_cards retain full counts, discloses no continuation-page fetching, and states row/KiB truncation limits. This is unusually rich and actionable behavioral disclosure.

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 purpose is front-loaded and nearly every sentence adds behavioral value, so the length is justified. Minor grammar and punctuation issues, such as 'Makes one logical GET request Does not auto-fetch continuation pages', reduce polish without obscuring 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?

For a read tool with no annotations and no output schema, the description covers purpose, parameter semantics, response-interpretation cautions, pagination behavior, and truncation rules. The main gap is the missing default behavior when max_group_size is not supplied, and no explicit description of the overall return shape.

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 compensate. It explains that username is required and that max_group_size=1 or 2 limits the UID sample per group, which gives real semantic meaning beyond the schema. It does not specify the default when max_group_size is omitted, but the core parameter intent is clear.

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

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

The description opens with 'Read eligible card groups for an explicit username', which states a specific verb, resource, and the required input. Among the many conflict_* siblings, this is the only eligible-cards tool, so the resource is differentiable even without opening the schema.

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

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

The description implies when to use the tool: when an explicit username and eligible card groups are needed. However, it names no alternative tools and gives no exclusions or when-not-to-use guidance, so an agent gets only implied usage 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?

With no annotations, the description fully carries the transparency burden and does so well: it discloses the 200-row upstream vs bounded server response, single logical GET, no continuation-page fetching, 100-row/256-KiB local limits, truncation reporting, and refusal of oversized records without partial 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?

The purpose is front-loaded and the length is tolerable, but the text has a run-on ('Makes one logical GET request Does not auto-fetch'), grammar issues ('list are'), and the vague 'Other declared filters' sentence that adds confusion. It could be trimmed without losing 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 tool with no output schema, it covers the essential runtime behaviors: data scope, truncation limits, pagination stance, and failure behavior for oversized records. Missing details are the meaning of id and explicit response shape, but these are partially covered by 'totals and prize metadata by id'.

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

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

The schema has one bare parameter (id, string) with 0% coverage, and the description only says 'by id' plus meta notes about tool policy. It never explains what the id identifies, its expected format, or how to obtain it. The reference to 'Other declared filters' is confusing because the schema has no additional filters.

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

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

The description opens with a specific verb ('Read') and names the resource ('conflict leaderboard') along with the scope ('totals and prize metadata by id'). It does not explicitly contrast with sibling leaderboard tools, so it misses the differentiator needed for 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 description explains behavioral constraints (bounded rows, no pagination, no auto-fetch) but never says when to use this tool versus conflict_player_rank, conflict_status, or player_leaderboard. Usage context is implied by the name, not 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?

With no annotations, the description carries the full burden and does so richly: it clarifies the response shape (player-only, not the full leaderboard), preserves string wire types for rank and contribution, states it makes one logical GET request, does not auto-fetch continuation pages, forwards declared filters without implying effectiveness, and reports truncation/refusal behavior for array responses. This goes far beyond a bare 'read' statement.

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 purpose is front-loaded and most sentences carry behavior information, but the description is dense and includes generic caveats such as 'Required inputs reflect tool policy as well as measured upstream requirements' and 'Other declared filters are forwarded as supplied' that add noise for a simple two-parameter tool. There is also a missing period between 'GET request' and 'Does not auto-fetch'.

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

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

For a simple two-parameter read tool with no output schema, the description covers the key operational facts: what is returned (player-only response), type behavior (string rank/contribution), single-request behavior, and pagination/truncation limits. It could additionally name a sibling endpoint for full leaderboards and describe error or empty-player behavior, but nothing essential for making the call is absent.

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

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

Schema coverage is 0% and the parameters are only defined as non-empty strings. The description adds that both id and username are used to look up the player's ranking, but it never clarifies what 'id' refers to (e.g. player id, season id, account id) or gives any value format beyond the schema's minLength. The mention of 'other declared filters' is also ambiguous given the schema has additionalProperties=false, so compensation is partial.

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 first sentence names a specific verb ('Read'), a specific resource ('one player's conflict ranking'), and the two lookup keys ('id and username'). It also explicitly disambiguates from the upstream 'leaderboard_with_player' name by stating the captured response contains only the player, not the whole leaderboard, which distinguishes it from sibling leaderboard tools.

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

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

The description clearly states the intended use: retrieve a single player's conflict ranking by id and username. It also implies a when-not by explaining the response is not the whole leaderboard and that continuation pages are not auto-fetched. However, it never names an alternative endpoint such as conflict_leaderboard or player_leaderboard_with_player, so explicit routing guidance is missing.

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 no annotations, the description carries the full behavioral burden and does substantial work: it discloses a single logical GET request, no automatic continuation-page fetching, a 100-row/256 KiB local limit, truncation reporting, refusal of oversized records, and filter passthrough caveats. Some behavioral statements remain unclear, and auth or error semantics are absent, but the disclosed operational constraints are genuinely useful.

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

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

The description repeats the same filter-passthrough warning twice and contains punctuation issues like 'request Does' without a period. Useful details are present, but they are buried under redundant disclaimers and vague meta-commentary, so the structure does not make every sentence earn its place.

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

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

The description covers operational limits and pagination well for a read endpoint, but with no output schema and no annotations, it must also clarify parameters and return shape. It leaves the required `player` parameter undefined and does not describe the response format beyond threshold and truncation metadata, so an agent cannot confidently construct a correct call.

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% with 9 parameters, so the description must compensate heavily. It only clarifies that id/conflict are selectors and vaguely states that other filters are forwarded without implied effectiveness. The required `player` parameter and most other parameters (`mode`, `uids`, `order_by`, `non_zero_rp`, `airdrop_data`) remain essentially undefined.

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

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

The description clearly states a specific read operation: reading a player's conflict reward-point record and reward_point_threshold, and identifies id/conflict as selector inputs. However, it does not distinguish this tool from related conflict siblings and the phrase 'Both aliases selected the captured current conflict' is grammatically confusing.

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 such as conflict_player_rank or conflict_leaderboard. The description only warns that non-primary filters are forwarded without presumed effectiveness; it offers no preconditions, exclusions, or decision rules.

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?

Despite having no annotations, the description thoroughly discloses behavior: 'response shape depends on the selector', 'Makes one logical GET request', 'Does not auto-fetch continuation pages', 'Array responses are locally limited to 100 rows and 256 KiB', and 'Oversized records are refused without partial fields'. It also notes that 'Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema', which is a critical caveat. This is an exceptionally transparent description for a tool without annotation support.

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

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

The description is front-loaded with the core purpose and then provides a dense but valuable set of behavioral details. It is a bit long and has a minor typo ('request Does'), but each sentence adds distinct information, and the structure moves from purpose to selector semantics to request behavior to local limits. No sentence is wasted.

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

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

The description thoroughly covers request behavior, limits, and truncation, but it lacks an explanation of the actual return data: there is no output schema and no description of what fields compose a 'conflict season' beyond a passing mention of 'nullable prize settings'. It also leaves the meaning of 'lore' unexplained. For a tool with no output schema and 0% parameter coverage, this is a noticeable gap in completeness, even though other aspects are well covered.

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

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

The schema provides no descriptions for 'id' or 'lore' (0% coverage), so the description must carry the burden. It does: 'Without id the upstream returned 24 records; an explicit id returned one object' gives practical semantics for 'id', and 'Other declared filters are forwarded as supplied; their effectiveness is not implied' warns about the reliability of filters like 'lore'. This adds meaningful guidance beyond the bare schema, though it could be more explicit about the exact meaning or format of each parameter.

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 opening phrase 'Read conflict seasons' clearly states a specific verb and resource, which distinguishes it from most sibling tools like conflict_status or conflict_players. However, it does not explain what a 'season' contains or explicitly differentiate from the other conflict_* tools, leaving some ambiguity for an agent unfamiliar with 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?

No guidance is given on when to use this tool versus alternatives. The description explains that the 'id' selector changes the response shape, but it never states conditions such as 'use this to list all seasons' or 'use this when you need a specific season by id' in comparison to other conflict-related tools. Context about required inputs is vague ('Required inputs reflect tool policy') but does not help choose between 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 no annotations, the description carries the full burden and does so exceptionally well. It discloses flag behavior, that only_config=true does not reduce the response, the single-GET behavior, lack of continuation-page auto-fetching, local wagon limits, truncation reporting, and refusal of oversized records without partial fields. This is far beyond typical descriptions.

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

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

The description is dense and information-rich, with no filler sentences. It is slightly run-on and would benefit from clearer separation, but every sentence adds meaningful operational detail and the core purpose is front-loaded.

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

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

Given the complexity (12 parameters, no annotations, no output schema), the description covers a remarkable amount: purpose, flag behavior, request count, pagination behavior, result limits, truncation, and oversize handling. It still leaves the full response shape and the semantics of several flags implicit, but it is substantially complete for an agent to invoke the tool safely.

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 compensate. It explains only_config, only_wagons, and exclude_wagons with concrete examples, and adds a general caveat that other declared filters are forwarded without implied effectiveness. However, most of the 12 parameters (lore, only_stats, exclude_stats, only_conflict, etc.) are not individually described, leaving an agent to infer their semantics from the naming pattern.

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

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

The description opens with a specific verb and resource: 'Read conflict configuration, current conflict, player statistics and wagons for an explicit username.' This clearly identifies the tool's scope and differentiates it from sibling conflict_* endpoints by describing a combined status read rather than a single list or rank lookup.

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 makes the intended use clear: call this when you need a bundle of conflict-related data for a specific username. It does not explicitly name alternatives or state when not to use it, but the context is strong enough that an agent can infer when it applies.

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 no annotations, the description thoroughly discloses error handling (unknown uid returns error), read-only guarantee, single GET request, no auto-pagination, response limits (100 rows/256 KiB) with truncation reporting, and refusal of oversized records. It also clarifies filter forwarding semantics. This goes well beyond basic expectations.

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?

Description is dense but every sentence adds value, covering purpose, error behavior, safety, network behavior, pagination, limits, and filter semantics. It's front-loaded with the core purpose and structured logically.

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

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

For a simple read tool with one parameter and no output schema, the description covers return content (card list, contribution values), error handling, and limits. No gaps that would prevent correct invocation.

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

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

Schema coverage is 0%, but description clarifies that uid is the explicit identifier and required. It adds semantic meaning ('explicit uid') beyond the schema's plain string type, and notes that required inputs reflect policy. However, it doesn't specify format beyond that, but with only one param, this is sufficient.

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 specific verb 'read', resource 'wagon', and scope 'by explicit uid'. Distinguishes from other conflict_* tools by specifying it's a single-wagon read, and explicitly notes it never stakes or removes cards, reinforcing read-only nature.

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?

Implies usage when you have a uid and want wagon details, but does not mention alternative tools or when not to use. The note about 'required inputs reflect tool policy' hints at necessity but doesn't provide exclusions or alternatives.

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

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

With no annotations, the description carries full burden and does so extensively: it discloses paging limitations ('no automatic paging', 'one bounded GET'), data size limits (100 rows, 256 KiB), truncation reporting, refusal of oversized records, and explicit statements about no currency conversion or card-delegation inference. This is rich behavioral context.

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

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

The description is verbose and repetitive. Statements like 'One bounded GET; no automatic paging' and 'Makes one logical GET request Does not auto-fetch continuation pages' are redundant. The text is a wall of loosely connected clauses with punctuation issues, lacking clear structure and front-loading.

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

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

The description covers behavioral limits thoroughly but leaves gaps: it does not explain parameter semantics or describe the return format (no output schema). While it hints at fields (amount strings, rental fields, nullable dates), it does not provide enough for an agent to confidently construct a correct call without additional inference.

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 compensate. However, it does not explain individual parameters like player, limit, sort, order, or offset. It only generically mentions 'required inputs reflect tool policy' and 'other declared filters are forwarded as supplied' without specifying which parameters are filters or their meanings.

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

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

The description states a specific action: 'Read incoming SPSP delegation records' and clarifies that each returned player is a delegator to the requested player. This distinguishes it from siblings like delegations_outgoing and delegation_to_target, which are clearly different directions or targets.

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 for incoming delegations but does not explicitly name alternatives or conditions for when to use this tool versus delegations_outgoing or delegation_to_target. It mentions matching 'corresponding outgoing and pairwise reads' but gives no clear when-to-use guidance.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly: it discloses no auto-paging, no currency conversion or card-delegation inference, local row and byte limits, truncation reporting, and refusal of oversized records without partial fields. This is far more behavioral context than most tool descriptions provide.

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

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

The description is front-loaded with the core purpose, but it becomes verbose and redundant. 'One bounded GET; no automatic paging' and 'Makes one logical GET request Does not auto-fetch continuation pages' say the same thing twice, and the odd 'Two pages of two matched the first four records' sentence adds confusion rather than value.

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

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

The description covers many operational expectations: paging behavior, size limits, truncation, and preservation of data types. However, it omits paging mechanics (how to use offset/limit to traverse results) and leaves the meaning of sort/order ambiguous, which an agent would need for correct invocation of this five-parameter 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 compensate, but it only meaningfully clarifies 'player' and 'limit'. Sort, order, and offset are left uninterpreted; 'sort effectiveness is unmeasured' and 'other declared filters are forwarded as supplied' do not explain their semantics or expected formats. This is a significant gap for a five-parameter tool.

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'), names the exact resource ('outgoing SPSP delegation records'), and clarifies the directionality: 'each returned player is a recipient of the explicitly requested player.' This clearly distinguishes it from sibling tools like delegations_incoming without needing to open their 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?

The intended use is implied by the purpose statement: call this when you need outgoing delegation records for a given player. However, it does not explicitly state when not to use it or name alternative tools such as delegations_incoming, so guidance is present but not fully developed.

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 no annotations provided, the description carries the full burden, and it is exceptionally transparent. It discloses read-only nature, HTTP 404 for reversed pairs, the zero-amount historical object caveat, preservation of fields, absence of currency conversion, bounded GET, no auto-paging, forwarding of filters without effectiveness guarantee, array limits, truncation reporting, and refusal of oversized records. This goes far beyond typical descriptions.

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

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

The description is verbose and contains redundancy: 'One bounded GET; no automatic paging.' and 'Makes one logical GET request Does not auto-fetch continuation pages.' say essentially the same thing. The structure is a stream of clauses rather than organized sentences. However, the core purpose is front-loaded, and the extra details are useful despite the lack of polish.

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

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

For a tool with only 2 parameters and no output schema, the description covers virtually every aspect an agent needs: purpose, expected behavior, failure modes, data handling, limits, and caveats. It even hints at response fields (amount strings, rental fields, nullable dates). It is sufficiently complete for correct invocation without ambiguity.

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 compensate. It does clarify directionality ('from explicit player to explicit target') and states that required inputs reflect tool policy. However, it does not elaborate on the parameters' data types, formats, or additional constraints beyond what the schema already provides (strings, minLength 1). Some value is added, but it is not comprehensive.

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

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

Clearly states a specific verb and resource: 'Read the directed SPSP delegation from explicit player to explicit target.' This distinguishes it from siblings like delegations_outgoing and delegations_incoming, which imply broader or direction-based listing. The detail about reversing the pair returning 404 further differentiates it as a directed pair lookup.

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

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

Provides clear context: it is for a specific directed pair, and notes that reversing the pair fails. It also clarifies exclusions ('No currency conversion or card-delegation inference') and mentions bounded GET without paging. However, it does not explicitly name alternative tools or state 'use this instead of X when Y', so guidance is implicit rather than explicit.

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 no annotations provided, the description carries the behavioral disclosure burden. It explicitly states the tool is offline and makes no upstream request, which is a critical behavioral guarantee. It also describes the output categories, helping an agent understand what to expect. It stops short of explicitly declaring 'read-only' or discussing side effects, but the wording strongly implies a safe, non-mutating operation.

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

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

The description is two sentences with zero waste. The first sentence front-loads the purpose and output specifics, and the second adds the key offline/no-upstream behavior. Every word contributes to the agent's understanding.

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

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

For a simple one-parameter tool with no output schema and no annotations, the description covers purpose, output content, and offline behavior. It would be slightly more complete if it pointed to list_endpoints as the source for entryId, but the tool is simple enough that an agent can still use it correctly based on this description.

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 compensate. It implies entryId identifies which catalogued endpoint to describe, but it does not explicitly state that entryId is the endpoint's catalogue identifier or explain how an agent should discover it (e.g., via list_endpoints). This is minimal compensation; the meaning of the parameter is only indirectly inferred.

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

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

The description uses a specific verb and resource: 'Describe one catalogued endpoint' and enumerates exactly what it returns (parameters, result contract, evidence dimensions, provenance). This clearly separates it from list_endpoints (which lists endpoints) and from data-fetching tools like transaction_inspect. The offline statement further distinguishes it from live-query siblings.

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 for retrieving metadata about a single endpoint rather than live data, and the offline note suggests it is safe to call without network effects. However, it does not explicitly state when to use this tool versus list_endpoints or other data-fetching siblings, nor does it mention that entryId likely comes from list_endpoints. There are no explicit exclusions.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure and excels at it. It discloses 24-hour caching, 100-row/256 KiB limits with truncation notices, cache keying, a single GET request, lack of auto-fetch, filter forwarding semantics, and refusal of oversized records. This is unusually thorough.

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

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

The description is a dense single paragraph with several run-on constructions (e.g., missing period before 'Does not auto-fetch'). While every sentence carries useful behavioral information, the lack of structure and overwrought phrasing makes it harder to parse than necessary. It would benefit from bullet points or shorter sentences.

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?

There is no output schema, so the description must explain return values. It states that array responses are bounded and truncation is reported, but it does not hint at the actual fields of a prize (e.g., name, rarity, quantity). For a simple no-parameter tool, this is a moderate gap; an agent knows it gets a list but not what a prize entry contains.

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

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

The input schema has zero parameters, so the baseline is 4 per the rubric. The description mentions 'required inputs' and 'declared filters' as if parameters existed, which is slightly confusing given the empty schema, but since there are no parameters, it does not need to add parameter semantics.

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

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

The description opens with 'Read currently available frontier draw prizes,' which names a specific verb, resource, and scope. It clearly distinguishes this from sibling tools like frontier_draws_recent_prizes or frontier_draws_prize_overview by focusing on 'available' prizes, which is a different concept.

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 about when to use this tool versus alternatives such as frontier_draws_recent_prizes or ranked_draws_available_prizes. The description focuses entirely on behavioral details (caching, bounds) but never states a selection criterion or exclusion, leaving the agent to infer usage from the name 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?

With no annotations, the description carries the transparency burden and does so thoroughly: the upstream list is unbounded, the server caps at 100 rows/256 KiB with an explicit truncation notice, it performs one logical GET and does not auto-fetch continuation pages, and oversized records are refused without partial fields. This gives an agent realistic expectations about pagination and truncation.

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 key limit 'at most 100 rows and 256 KiB' and the truncation reporting are repeated almost verbatim twice. The sentence 'Makes one logical GET request Does not auto-fetch continuation pages' also has a missing period, showing poor polish. The purpose is front-loaded, but the redundancy makes it wordy.

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 endpoint, the truncation and single-request behavior are well covered. However, the return data is only vaguely described as 'verification data,' the filter/input prose conflicts with the closed empty schema, and there is no guidance on how this endpoint relates to sibling draw endpoints. It is adequate but not complete.

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

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

The schema declares zero properties and additionalProperties false, so an agent needs no parameter documentation. However, the description mentions 'required inputs' and 'declared filters' despite there being none in the schema, which is vacuous and could mislead an agent into thinking inputs are 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?

The description opens with a clear verb and resource: 'Read completed frontier draws and their verification data.' This distinguishes it from the frontier_draws_status/prize_overview/entries_completed siblings by focusing on completed draws plus verification data, 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?

The intended use is only implied by the opening phrase; there is no explicit when-to-use or when-not-to-use guidance, and no named alternative such as frontier_draws_status or frontier_draws_entries_completed. The rest of the description is behavioral caveats rather than usage direction.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the 100-row and 256 KiB limits, the truncation notice, the lack of auto-pagination, the forwarding of filters without implying effectiveness, and the refusal of oversized records. This is exceptionally transparent and goes beyond typical tool descriptions.

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

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

The description is information-dense and front-loaded with the core purpose. However, it repeats the '100 rows and 256 KiB' limit twice (once for the upstream list, once for array responses), which is slightly redundant. The structure is logical, but the repetition could be trimmed without losing clarity.

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

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

For a simple read tool with one parameter and no output schema, the description covers all essential aspects: what it does, the limits, truncation behavior, pagination policy, and edge-case handling. It is complete for an agent to correctly invoke the tool and interpret the response, even without annotations or an output schema.

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

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

Only one parameter (id) exists, and the schema has no description (coverage 0%). The description clarifies that the id is numeric and refers to a frontier draw, which adds some meaning beyond the raw schema. However, it does not explain what a frontier draw id is or how to obtain it, and the statement 'Required inputs reflect tool policy' is vague. The description adds minimal value over the schema's type and range constraints.

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

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

The description clearly states the action ('Read'), the resource ('completed-entry rows'), and the scope ('for one explicit numeric frontier draw id'). This distinguishes it from sibling tools like frontier_draws_complete or frontier_draws_recent_prizes, which serve different purposes.

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 makes it clear this tool is for retrieving completed entries for a specific draw id. It implies the use case (when you have a frontier draw id and need its completed entries) but does not explicitly mention alternatives or when not to use it. The context from the name and sibling list is sufficient, but explicit routing would be stronger.

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 no annotations provided, the description carries the full behavioral burden and does so thoroughly. It discloses 24-hour caching, bounded success caching keyed by exact query, single logical GET behavior, no continuation-page auto-fetch, local row/size limits, truncation reporting, and refusal of oversized records. This is rich, concrete transparency with no contradiction.

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

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

The purpose is front-loaded in the first sentence, and the behavioral details are valuable. However, the second sentence is a run-on with a missing period before 'Does', and some boilerplate about required inputs and filters feels irrelevant for an empty schema. Overall compact but not polished.

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 endpoint, the description covers the key operational context: caching, truncation, refusal behavior, and the high-level content returned. It does not describe the exact return shape, but no output schema exists and the endpoint's simplicity lowers the burden.

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

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

The input schema is empty, so there are no parameter semantics to explain; a baseline of 4 is appropriate. The description's remarks about required inputs and forwarded filters are somewhat generic and not fully applicable to a zero-parameter endpoint, but they do not mislead.

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

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

The description opens with a specific verb and resource — 'Read the frontier draw prize totals and foil breakdowns' — which clearly distinguishes it from sibling endpoints like ranked_draws_prize_overview and frontier_draws_status. The scope is precise and usable 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?

There is no explicit guidance on when to use this tool over alternatives, nor any mention of when not to use it. The only adjacent statements are behavioral caveats about caching and limits, which are not selection criteria. An agent must infer the intended use case from the name 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?

With no annotations, the description carries the full burden and does disclose key behaviors: the 100-row/256 KiB limits, explicit truncation notice, single GET request, no auto-pagination, and refusal of oversized records. This is rich behavioral disclosure, though the repeated limit statement and confusing filter language slightly reduce clarity.

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

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

The description repeats the 100-row and 256 KiB limit twice and includes a run-on sentence about the GET request. It also includes boilerplate-sounding phrases like 'Required inputs reflect tool policy' and 'Other declared filters are forwarded as supplied,' which add noise without value. The core information could be stated in half the length.

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, no-output-schema read tool, the description covers the essential constraints and behavior adequately. However, it fails to clarify the relationship to the similarly named ranked_draws_recent_prizes, and the mention of nonexistent filters makes the context slightly muddled. The truncation and pagination behavior are well covered.

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

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

The input schema has zero parameters and 100% coverage, so the baseline for this dimension is high. The description adds little meaningful parameter semantics; the references to 'required inputs' and 'declared filters' are misleading because the schema declares no parameters. Overall, the empty schema already communicates the parameter surface completely.

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 begins with 'Read recent frontier draw mints,' which uses a clear verb and resource. It distinguishes the tool from the many sibling endpoints by naming 'frontier' specifically, though it does not explicitly contrast it with ranked_draws_recent_prizes or other related tools.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as ranked_draws_recent_prizes. The statements about request behavior and truncation are operational notes, not usage-selection guidance. Mentions of 'required inputs' and 'declared filters' are vague and potentially confusing given the schema has zero parameters.

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 no annotations, the description carries the full burden and provides substantial behavior: it is a logical GET, it does not auto-fetch continuation pages, array responses are capped at 100 rows and 256 KiB, truncation is reported, and oversized records are refused without partial fields. This is strong operational transparency despite some boilerplate about 'required inputs' and 'other declared filters' that does not match 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?

The main purpose and key behaviors are front-loaded, but the description contains generic boilerplate sentences—'Required inputs reflect tool policy...' and 'Other declared filters are forwarded as supplied...'—that are confusing and largely irrelevant for a schema with one optional string and no additional properties. There is also a missing period after 'GET request'. It is somewhat over-built for its 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?

The tool is low-complexity and the description covers input scope, optional filtering, request behavior, and response limits. However, there is no output schema, and the description does not clarify what fields or structure the draw status response contains, leaving the agent to discover the return shape at runtime.

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%, and there is only one optional parameter, username. The description compensates by explaining that username is optional, acts as an explicit account-scoped selector when supplied, and that no account is assumed when omitted. This adds meaningful semantics beyond the parameter name and type.

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

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

The description opens with a specific verb and resource: 'Read the current and first-unclaimed frontier draw status.' This clearly identifies the operation and distinguishes it from ranked draw status tools, though it does not explicitly name sibling alternatives. The mention of 'current and first-unclaimed' adds useful scope beyond the bare tool name.

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

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

The description gives some context for the optional username parameter ('forwarded as an explicit account-scoped selector... no account is assumed') but never states when to choose this tool over siblings like frontier_draws_prize_overview or ranked_draws_status. There is no when-not-to-use guidance or explicit alternative routing, so the agent must infer usage from the name.

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 no annotations provided, the description carries full burden and covers key behaviors: not cached by settings cache, single GET, no auto-pagination, and array limits with truncation. This is strong disclosure for a simple tool, though it doesn't discuss error handling or response format beyond truncation.

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

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

The description is tight and front-loaded with the core purpose, followed by important caveats. Each sentence adds distinct value with no redundancy, and it remains concise despite covering multiple behavioral details.

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

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

Given zero parameters, no output schema, and low complexity, the description covers all necessary operational aspects: caching, request nature, pagination behavior, and response limits. An agent can call this tool correctly without additional info.

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?

Since there are no parameters, the schema is trivial. The description adds value by explaining that required inputs (none) reflect tool policy and upstream requirements, and that any other declared filters are forwarded as supplied. This compensates for the empty schema.

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

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

The description clearly states 'Read the latest block number reported by the game API' with a specific verb and resource. However, it does not explicitly differentiate from sibling tools like game_settings or list_endpoints, though the uniqueness of 'latest block number' makes it distinct enough.

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 simple usage: no inputs, one GET request, and no pagination. But it does not explicitly state when to use this tool versus alternatives or when not to use it. The context of it being a lightweight status read is clear, but exclusions are absent.

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 no annotations, the description fully carries the behavioral disclosure burden. It explicitly notes single-GET behavior, no continuation-page auto-fetch, the local row/size limits, truncation reporting, and oversized-record refusal. It even discloses that filter effectiveness is not fully established, which is unusually honest and useful.

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

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

The description packs in useful detail but is structurally messy, with run-on sentences and missing punctuation ('one logical GET request Does not auto-fetch'). It front-loads the purpose but then meanders into vague statements like 'Required inputs reflect tool policy as well as measured upstream requirements' which adds little. Dense but not polished.

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

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

For a two-optional-parameter read endpoint with no output schema and no annotations, the description covers the essential context: return contents, filtering caveats, pagination behavior, local limits, truncation notification, and error handling. Minor gaps like exact date formatting and the meaning of 'window_buffer_ms' prevent a perfect score.

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 compensate. It does add that start_date/end_date are explicit date bounds that get forwarded, and mentions a tested September range that retained the same window, implying uncertain filtering. However, it does not explain expected date format, boundary inclusivity, or how the parameters affect the returned data, leaving the caller under-informed.

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

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

The description opens with a specific verb and resource: 'Read scheduled maintenance windows and window_buffer_ms.' This clearly identifies the tool's operation and output. It also distinguishes itself from the many sibling endpoints by focusing on the maintenance domain, leaving no ambiguity about what resource it targets.

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 or alternative-selection guidance is provided. The description does not state when a caller should choose this tool over any sibling, nor does it give context for typical use cases. The filtering caveat hints at behavior but not at usage 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?

With no annotations at all, the description carries the full burden and does an excellent job. It discloses caching duration, non-delta behavior, bounded cache mechanics, request method, pagination handling, filter forwarding caveats, array size limits, truncation reporting, and oversized-record refusal. This is far beyond typical descriptions and gives an agent a realistic model of the tool's 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?

The description is dense and information-rich, but it includes boilerplate like 'Required inputs reflect tool policy as well as measured upstream requirements' which adds little and could confuse given there are no required parameters. It is structured around behaviors but could be trimmed without losing essential 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 simple read tool with two optional params and no output schema, this description covers most operational aspects: caching, request pattern, pagination, limits, and error behavior. It mentions the response is the 'full settings body'. The main gap is the lack of clear parameter value guidance and response structure, but overall it is sufficiently complete for an agent to invoke correctly.

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

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

Schema coverage is 0%, so the description must compensate. It adds the key fact that version and config_version do not trigger a delta response—they still return the full body. It also notes that filters are forwarded without effectiveness guarantees. However, it never explains what these parameters semantically represent, what formats are expected, or what happens when they are omitted. Some value is added, but significant ambiguity remains.

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

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

The description opens with 'Read current public settings from the API', which names a specific verb and resource, making the core purpose clear. It does not explicitly contrast with sibling tools like purchase_settings or game_maintenance, so it stops short of full differentiation in the same space.

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 by the purpose: call this when you need current public settings. However, there is no explicit guidance on when to prefer this over alternatives, when not to use it, or conditions that would make another tool more appropriate. The caching/behavior details add context but not decision rules.

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 no annotations, the description carries full burden and goes well beyond basics: one logical GET, no continuation fetching, local array truncation limits, refusal of oversized records, and forwarding of filters without implied effectiveness. This is rich behavioral disclosure.

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 core purpose is front-loaded, but several sentences are generic boilerplate unrelated to a no-parameter tool ('Required inputs...', 'Other declared filters...'), and there is also a missing period between 'GET request' and 'Does not'. These distract from the otherwise useful behavioral notes.

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

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

For a simple no-input health endpoint, the description covers what it returns, its read-only nature, request behavior, and local limits. The boilerplate about filters and inputs slightly muddies completeness, but the essential information an agent needs is present.

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

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

The schema has zero properties and 100% coverage, so there are no parameters to document; baseline 4 applies. The comment about required inputs and filters is generic boilerplate and doesn't add meaning for this no-input tool.

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

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

Clearly identifies a specific operation: reading the public VAPI health root and the metadata it returns (status, app/version/environment). The caveat that it is not a claim about game route availability distinguishes it from game-status siblings.

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 clear context that this is a health read and explicitly disclaims routing availability, so an agent understands its scope. It doesn't name a specific alternative for checking individual game routes, but the limitation is enough to guide selection.

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

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

With no annotations, the description carries full responsibility and does an excellent job: it discloses pagination behavior ('Does not auto-fetch continuation pages'), local limits (100 rows, 256 KiB), truncation reporting, refusal of oversized records, decimal-string payouts, and non-guaranteed filters. This goes well beyond typical tool descriptions.

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

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

The description is front-loaded with the core purpose and contains substantive caveats, but it is dense and contains redundancy ('Other tournament and date selectors remain forwarded but unverified' vs. 'Other declared filters are forwarded as supplied'). There are also grammar/punctuation issues, such as 'Makes one logical GET request Does not auto-fetch continuation pages.'

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

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

For a tool with 7 parameters, no annotations, and no output schema, the description is unusually complete: it covers limits, pagination, truncation, data formatting, and filter reliability. It stops short of describing the full response shape or error behavior, but the core operational context an agent needs is present.

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 compensate. It adds meaning for cycle ('selected one row'), start_cycle, and end_cycle ('inclusive endpoint cycles'), and groups tournament/date selectors as forwarded but unverified. However, guild_id is only implied, and the remaining selectors are not individually explained, leaving several parameters underspecified.

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 opening sentence 'Read brawl records for an explicit guild' provides a clear verb, resource, and scope. It does not explicitly differentiate from the sibling guild_brawl_sps_rewards, but 'brawl records' versus 'SPS rewards' is reasonably distinct.

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 for a known guild and warns that tournament/date selectors are 'forwarded but unverified,' which is useful context. However, it never explicitly states when to use this tool instead of related guild or brawl tools, nor does it mention alternatives.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly. It discloses one logical GET request, no auto-fetching of continuation pages, 100-row/256 KiB local limits, truncation reporting, refusal of oversized records without partial fields, and the important semantic that the total is not a guild or selected-cycle sum.

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

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

The description is a dense, run-on block with missing punctuation and awkward phrasing, e.g., 'Makes one logical GET request Does not auto-fetch continuation pages.' It front-loads the purpose well but the many disjointed caveats make it harder to parse than necessary.

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

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

Given no output schema and no annotations, the description covers a lot: request behavior, pagination/continuation behavior, response truncation limits, and filter semantics. It stops short of describing the actual response shape or authentication needs, but for a read-only payout endpoint the provided context is largely sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It does meaningfully explain include_total/include_cycles with the string '1' convention, clarifies that cycle narrows records while the total remains global, and warns that other filters are forwarded as supplied without implied effectiveness. However, start_cycle, end_cycle, and cycle are only loosely addressed and not fully pinned down.

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

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

The description opens with a specific verb and resource: 'Read global brawl SPS payout totals and/or cycle records.' It clearly scopes the tool to global SPS payout data and distinguishes it from sibling tools like guild_brawl_records by emphasizing 'global' and 'payout totals' rather than generic brawl records.

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

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

The description provides practical usage context, such as 'Each section can be selected independently' and notes that the total is global even when a cycle narrows records. However, it never names alternative tools or gives explicit when-to-use vs. when-not-to-use guidance relative to siblings, so the guidance is implied rather than direct.

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

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

The description is exceptionally detailed about behavioral traits: it states it makes one logical GET request, does not auto-fetch continuation pages, locally limits array responses to 100 rows and 256 KiB with truncation reported, refuses oversized records without partial fields, preserves original units and wire values, and clarifies that other declared filters are forwarded without implied effectiveness. Given no annotations, this fully compensates for the lack of metadata.

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

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

The description is packed with information but structured as a single dense paragraph with multiple clauses. It begins with purpose (good) but then intermixes behavioral caveats, observations, and limitations without clear paragraphs or bullet points. It is not excessively long, but the lack of hierarchy makes it harder to scan. It is adequately concise but could be better organized.

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

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

Given there is no output schema, the description must explain the return shape. It mentions row counts, 'amounts' and 'cumulative fields', and truncation behavior, but does not describe the structure of a contribution record, what fields are returned, or how they map to the parameters. It also lacks details on error handling or response envelope. This is insufficient for an agent to fully understand what it will receive.

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

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

The description adds some meaning beyond the schema by providing concrete examples of the 'type' parameter ('guild_hall' and 'arena') and noting that omitting it results in empty output. It also mentions that required inputs reflect upstream requirements. However, it does not enumerate all valid type values or explain the semantics of 'guild_id' beyond the term 'guild'. It partially compensates for the 0% schema description coverage but leaves gaps.

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

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

States a specific verb ('Read') and resource ('contributions for a guild and explicit building type'), clearly distinguishing it from other guild-related tools like guild_list or guild_members. It also specifies the primary key ('guild_id' and 'type') and hints at distinct behavior for different building types, which is unambiguous.

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

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

The description implies usage by focusing on a specific resource and notes that omitting the type yields empty results, suggesting the type must be provided. However, it does not explicitly enumerate when to use this tool versus alternatives, nor does it name exclusion conditions or alternative tools. Some context is present but it is not comprehensive.

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 no annotations, the description carries the full behavioral burden, and it does so richly. It discloses JSON-encoded string wire types, a single logical GET, no continuation-page auto-fetch, array row/size limits, truncation reporting, and refusal of oversized records. It also warns against assuming ext=true expands the response.

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 core purpose is front-loaded, and nearly every sentence carries behaviorally important information. The wording is dense and occasionally awkward, with a missing period after 'request' and the confusing 'included extra fields absent with ext=true' phrase, but there is little redundancy.

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

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

For a low-complexity single-get tool, the description covers request behavior, wire types, response limits, and safety well. However, it leaves gaps around return-value shape, error behavior, and the semantics of username and ext, so an agent is still guessing about optional parameters.

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 compensate. It clarifies that id is the explicit lookup key, but ext is described only through an opaque warning about extra fields, and username is never semantically explained. The line about filters being forwarded as supplied does not tell the agent what these parameters actually do.

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?

Opening sentence 'Read one guild by its explicit ID' states a specific verb, resource, and lookup key. This clearly distinguishes it from list- and member-oriented guild siblings, even though no sibling is named. The rest of the description is caveats, not purpose.

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 tool is clearly positioned as a single-guild lookup, implying it should be used when the caller already has an explicit guild ID. However, it never names an alternative like guild_list for when an ID is unavailable, and it gives no explicit when-not-to-use guidance. 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers extensively. It reveals the transport limit issue, the local limits (100 rows, 256 KiB), truncation reporting, refusal of oversized records, single GET request, and no auto-fetch of continuation pages. This is comprehensive transparency beyond what annotations would normally provide.

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

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

The description is front-loaded with the core purpose, but it is verbose and repetitive. The phrase 'Other declared filters are forwarded' appears twice, and the text could be tightened. It is not a model of conciseness, though it is structured with the key constraint first.

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

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

Given the tool's complexity (5 params, no output schema, no annotations), the description covers essential operational details: required name, limits, truncation, refusal behavior, and pagination. It does not describe the return format, but for a list endpoint with no output schema, the description provides enough for an agent to call it correctly and interpret basic results. Minor gaps remain around field descriptions.

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 compensate. It clarifies that 'name' is required and effective, and that other filters are forwarded but not guaranteed to work. However, it does not explain the meaning or expected format of sort_by, language, username, or membership_type. The description adds some value but leaves significant gaps for the non-required parameters.

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

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

The description opens with a specific verb and resource: 'Search guilds by an explicit name filter.' It clearly distinguishes this from sibling tools like guild_find and guild_members by focusing on the name-based search and the required filter. No ambiguity about what the tool does.

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

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

The description states the core usage: search by name filter, and explains why (unfiltered response exceeded transport limit). It also warns that other filters are forwarded without guaranteed effectiveness, guiding the agent to rely on the name filter. However, it does not explicitly name alternative tools or state when not to use this one, so it stops short of a full 5.

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

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

With no annotations, the description carries the full load and does so exceptionally. It reveals that membership status is not inferred, that limit/offset are ineffective and unsupported, that only one logical GET is made without auto-fetching continuation pages, and that array responses are capped at 100 rows / 256 KiB with truncation reported. It also notes that oversized records are refused without partial fields. These are concrete, non-obvious behaviors.

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

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

The description is dense but every sentence carries distinct information: purpose, empirical results, paging, request behavior, input policy, and array limits. It is front-loaded with the core purpose. One sentence ('Required inputs reflect tool policy...') is somewhat vague and could be cut, but overall it is well-structured for such a behaviorally complex tool.

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

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

Given there is no output schema, the description covers a lot: required input, optional filter, paging absence, request pattern, truncation, and refusal behavior. The only notable gap is that it never specifies the shape or fields of the membership rows themselves; an agent knows they are rows but not their content. Still, for a read-only lookup of this type, the description is nearly 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 0%, so the description must compensate. It does: it clarifies guild_id is required and explicit, explains that status is forwarded as supplied and not inferred, and documents the observed behavior of limit/offset (ineffective). It does not enumerate possible status values, but it adds meaningful semantics beyond the bare schema.

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

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

The description opens with a specific verb and resource: 'Read guild membership rows for an explicit guild_id.' This clearly distinguishes the tool from siblings like guild_list or guild_find, which target guild objects rather than membership rows for a known ID. The requirement of an explicit guild_id is stated up front.

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

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

The description implies the use case: you call this when you have a concrete guild_id and need its membership rows. It also explains the optional status filter with observed results. However, it never explicitly names alternatives or conditions when another tool (e.g., guild_find or guild_contributions) should be used instead, so the guidance remains implied rather than explicit.

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

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

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint false), the description adds crucial behavioral details: default limit (100), return of next_start for pagination even when no matches, no automatic pagination, local filter application, and refusal of oversized results. These are specific and useful for an agent to predict behavior, particularly around pagination and result size handling.

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

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

The description is a single, dense paragraph that front-loads the core purpose first, then covers defaults, filters, pagination, and caveats in order of importance. Every sentence adds value, with no filler or repetition. It is appropriately sized for the tool's complexity.

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

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

Given the tool has 5 parameters and no output schema, the description covers most critical behavior: purpose, default, filter semantics, pagination mechanism, and edge-case size limits. It does not describe the return format beyond mentioning next_start, but since there is no output schema, this is a minor gap. The description is sufficient for an agent to use the tool correctly in most cases, but a note about the response structure would have made it 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 schema has no parameter descriptions (coverage 0%), so the description must compensate. It mentions the default for limit ('newest 100 records') and explains the custom_json_id filter is applied locally, which adds meaning. However, it does not describe the 'start' parameter (only mentions next_start in return, implying its purpose) or the 'operation_type' parameter at all. Since over 40% of parameters (start, operation_type) are not explained in the description, this is a partial compensation, warranting a score of 3.

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

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

The description clearly states the tool searches a bounded window of an explicit Hive account's authority-indexed history, with a specific verb ('Search') and resource ('Hive account's authority-indexed history'). It also distinguishes itself from 'complete incoming-recipient history', clarifying what it is not, which helps the agent understand its scope.

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

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

The description provides important usage context: it explains the default behavior (newest 100 records), the local application of the custom_json_id filter, and the lack of automatic pagination, explicitly stating this is not a complete history. However, it does not name a specific alternative tool or explicitly say when to use this versus another, only implies that for complete history manual pagination would be needed. This is clear context but lacks an explicit exclusion.

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