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

No annotations are provided, so the description carries the burden of behavioral disclosure. It communicates that this is a listing/read-style query and clarifies the status filter, but it does not mention pagination behavior or explicitly state the read-only nature. The behavior implied is consistent with the tool's purpose.

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

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

Two sentences with no filler: the first states the core behavior and optional filter, and the second adds a practical use case. Information is front-loaded and every sentence earns its place.

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

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

The output schema covers return shape, and the description covers the main selection logic and filter values. Pagination parameters are simple and have defaults, so the tool can be called correctly. Minor omissions like invalid-address handling or limit bounds are not critical for this low-complexity query.

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

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

Schema description coverage is 0%, so the description must compensate. It adds useful meaning for 'address' (the entity being queried) and 'status' (open/closed filtering), but it does not explain 'page' or 'limit', leaving pagination semantics to be inferred from their names and defaults.

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

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

The description states a specific verb and resource: it returns all dispensers a Bitcoin address has opened, with optional status filtering. It is clear about the address scope and thereby distinguishable from generic siblings like stamp_dispensers, though it does not explicitly name alternatives.

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 concrete use case ('see what a seller currently lists'), which implies when this tool is helpful. However, it does not explicitly explain when to prefer this tool over sibling tools or state any 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 provided, the description carries the full burden. It discloses the return fields and the two parameter modes, but it does not clarify the behavior when both `block` and `last` are provided or when invalid inputs are given, nor does it state any error handling or side effects. This is adequate but has gaps.

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

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

The description is two sentences with no redundancy. The primary purpose is front-loaded, and the parameter explanation is compact yet complete. Every word contributes to understanding the tool's behavior.

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 an output schema available, so detailed return structure is likely covered. The description already mentions the key return fields. The only gap is the lack of guidance on edge cases (e.g., both parameters set, invalid block), but given the tool's simplicity, the description is nearly 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?

The schema documents only defaults and types; the description compensates fully by explaining that `block` accepts an index or hash and that `last` (1-50) returns the most recent N blocks. This adds critical meaning beyond the raw schema, which has 0% description 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 retrieves a Bitcoin block as the Stamps indexer sees it, specifying the return fields (block_time, hashes, tx_count). It also distinguishes the two modes of use (by block index/hash or via `last`), making the purpose unambiguous and distinct from siblings like stamps_in_block.

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

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

The description provides explicit usage instructions: how to specify a block by index/hash or retrieve recent blocks via `last`. However, it does not mention alternatives or when not to use this tool, such as distinguishing from related sibling tools like stamps_in_block, leaving the selection logic 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 carries full responsibility for behavioral disclosure. It does explain the conditional effect of include_market_data and that lookup can be by id or name, but it does not mention not-found behavior, authentication requirements, or any other operational side effects.

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

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

A single sentence packs the core purpose, lookup modes, returned content, and parameter-driven behavior. It is front-loaded and contains no filler.

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

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

Given the low complexity, the presence of an output schema, and clear parameter semantics, the description is nearly complete. The only minor gap is explicit guidance on when to use this tool versus listing collections, but that is not essential for a standard get-by-identifier operation.

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%, but the description compensates by explaining both parameters: collection can be a hex id or a name, and include_market_data controls whether floor price, volume, and holder metrics are returned. This fully covers what the bare schema lacks.

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 fetches one collection, identified by hex id or name, and returns its stamps plus optionally market data. This distinguishes it from list_collections and get_stamp by specifying the resource and retrieval mode.

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: call this when you need a specific collection's details by id or name. However, it does not explicitly say when to prefer list_collections or other siblings, nor does it provide exclusions or alternative conditions.

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 behavioral burden. It goes beyond a simple data list by warning that 7d/30d/total volume are often 0 or null due to upstream exchange behavior, and explicitly cautions against misinterpreting zero as 'no trading'. This is valuable, non-obvious 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 well-organized: a lead sentence conveying scope, a parenthetical breakdown of returned data, and a focused caveat sentence. Each sentence earns its place, and the important zero-volume warning is given prominent placement.

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 output schema exists, so detailed return fields do not need repetition. The description sufficiently explains the tool's aggregate nature, the data categories included, and a key data-quality quirk. It could add guidance on finding a tick or behavior for unknown ticks, but these are minor gaps given the simple single-parameter input.

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 implies that 'tick' identifies the SRC-20 token. It does not explain tick format, case sensitivity, or how to resolve a valid tick. The description should compensate more for the bare schema, but it still weakly ties the single parameter to the tool's purpose.

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: retrieve comprehensive data for one SRC-20 token. It enumerates the specific data groups (deploy record, mint status, market data), which distinguishes it from narrower sibling tools like src20_balance, src20_holders, or src20_market.

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

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

The phrase 'Everything about one SRC-20 token in one call' clearly communicates when to use this tool: when a single token's full picture is needed. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to choose this over single-purpose sibling tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does well by explaining conditional fields (market_data and lowestPriceDispenser only when the indexer has them) and the base64 payload behavior unless include_image_base64=True is set. It does not cover error or permission behavior, but the read-only nature is evident from 'get'.

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-sentence list that front-loads the key identifier semantics before enumerating return fields. No filler words are present, though the long enumeration makes it slightly harder to parse quickly.

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

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

For a two-parameter fetch with an output schema, the description is largely complete: it explains how to identify the stamp, what fields are returned, which fields are conditional, and the only important boolean flag. It could add explicit guidance on when not to use this tool versus search_stamps, but 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 schema only defines stamp_id as a string and include_image_base64 as a boolean, with 0% description coverage. The description compensates fully by explaining that stamp_id can be a stamp number, tx hash, or CPID, and by clarifying that the base64 image payload is dropped unless include_image_base64=True.

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's function: retrieve one stamp by number, tx hash, or CPID. It names the specific resource and the exact identifier forms, which distinguishes it from list/search sibling tools like list_stamps and search_stamps.

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

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

The description gives clear context for when to use the tool: when you have a known stamp number, tx hash, or CPID and want a single stamp's full details. It does not explicitly name alternatives or exclusion conditions, but the 'one stamp by exact identifier' framing is strong 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 of disclosing behavior. It only lists output fields and says nothing about read-only behavior, pagination semantics, ordering, limits, or side effects. The agent is left without any behavioral context beyond the tool name.

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

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

The description is very short, but it is under-specified rather than efficiently concise. It is a fragment listing fields, and it omits essential behavioral and usage information that should be included.

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 the tool is simple and an output schema exists, the description does not cover how to select this tool over siblings, what pagination behavior to expect, or any operational context. The minimal field list leaves significant gaps for an agent deciding whether and how to invoke this tool.

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

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

Schema description coverage is 0%, and the description does not mention the page or limit parameters at all. Since the schema only provides default values, the description fails to add any meaning about how pagination works or how these parameters affect the results.

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

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

The description identifies the resource ('Stamp collections') and enumerates returned fields, but it lacks a clear verb and does not explicitly state that this tool lists multiple collections. The title 'List Collections' helps, but the description alone is closer to a data dictionary than a purpose statement, and it does not distinguish itself from siblings like get_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?

There is no guidance about when to use this tool versus alternatives such as get_collection, list_stamps, or search_stamps. No context is given for pagination, filtering, or typical use cases, so the agent must infer usage from the tool name and schema.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the result ordering ('newest first'), the fields included, and the fact that it lists deploy transactions. It does not mention pagination behavior or rate limits, but for a read-only list tool the core behavior is well covered.

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 filler. The primary purpose and ordering are front-loaded, followed by a compact list of returned fields and then the routing guidance. Every phrase earns its place.

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

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

The output schema exists, so return-value details are available structurally. The description covers purpose, ordering, fields, and alternatives. The only notable gap is pagination semantics for the page/limit parameters, which is minor given the schema provides defaults.

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 for the undocumented parameters. It never mentions page or limit, leaving the agent to infer their meaning solely from parameter names and defaults. The description adds no value beyond the input schema.

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

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

The description states a specific resource ('SRC-20 DEPLOY transactions'), the ordering ('newest first'), and the exact fields returned (tick, max, lim, decimals, creator, block and time, deploy stamp URL). It also differentiates from related siblings by pointing to src20_market and get_src20, so an agent can tell this tool apart without opening 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 description explicitly gives routing guidance: 'For a ranked market view use src20_market; for mint progress use get_src20.' This tells the agent when NOT to use this tool and which alternative fits those specific needs, leaving no ambiguity about the intended use case.

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 behavioral disclosure burden. It reveals that results are paginated, ordered newest-first by default, sortable in both directions, and that market filters only apply to stamps with market data. It also explains key value semantics like floor price in BTC from open dispensers and the row-level ident field for protocol filtering. This is strong context, though it omits details like rate limits or explicit read-only 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?

Three compact sentences deliver pagination, sorting, filter semantics, and row-level protocol identification without fluff. Key behavioral details are front-loaded, and every sentence earns its place. No redundancy or vague filler.

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

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

For a read-only listing with 8 optional parameters and an output schema, the description covers the essential call semantics: pagination, sorting, filter meaning, and row identifiers. The output schema handles return shape, so that omission is acceptable. The main gap is the lack of explicit guidance about when to use this list endpoint versus search_stamps or other sibling endpoints.

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 beyond parameter names by explaining sort direction semantics, floor-price sourcing, market filter concepts, and the data_quality_score range. It does not explicitly map every min/max parameter, and page/limit are only generically covered by 'paginated', but the overall compensation is solid.

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

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

The description clearly identifies the tool as a paginated listing of stamps with sorting and optional market filters. It distinguishes itself from more specific siblings like get_stamp and search_stamps by describing listing behavior rather than single-item lookup or search. However, it does not explicitly say 'all stamps' or name sibling alternatives, so it stops short of maximum clarity.

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: use this to page through stamps, sort them, and apply market-data filters. It gives clear sorting and filter context but does not state when to choose this over search_stamps or other listing endpoints, nor any exclusions. Guidance is present but indirect.

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 behavioral burden. It does disclose the returned fields and the meaning of mintable_only=True, which is useful. However, it does not mention read-only behavior, pagination, result limits, or default filtering beyond the schema, leaving some behavioral gaps.

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

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

Three sentences, front-loaded with the core purpose, then output fields, then the main parameter behavior. Every sentence adds value, and the description is appropriately sized for the tool's simplicity.

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 an output schema exists, the description does not need to repeat return value structure. The tool has only two parameters and both are semantically covered. It is missing only explicit sibling routing and notes on edge cases, so it is nearly complete for effective 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 description coverage is 0%, so the description must explain the parameters. It does: 'q' is a tick fragment and 'mintable_only=True' filters to tokens under 100% progress. This compensates for the schema's lack of descriptions, though it could add detail about matching behavior or result limits.

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 action and resource: 'Search SRC-20 tokens by tick fragment.' It clearly defines what the tool does and lists the returned fields. However, it does not explicitly differentiate itself from sibling tools like get_src20 or list_src20_deploys, so it does not earn 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 phrase 'by tick fragment' implies this tool is for partial-ticker search rather than exact lookup, which gives some usage context. But no alternatives are named, and there is no explicit guidance about when to prefer this tool over related siblings like get_src20 or src20_market.

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 discloses what the search returns (stamp number, CPID, preview URL, mimetype, creator, tx hash) and highlights a notable behavior: negative stamp numbers are 'cursed' stamps that are pre-protocol-rule artifacts but still indexed. This goes beyond the obvious 'search' semantics, though it omits details like pagination or result limits.

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

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

The description is two sentences with no filler. It front-loads the core purpose, then provides query examples, return fields, and a useful edge-case note about cursed stamps. Every sentence adds 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 tool is simple with one required parameter, and the description explains both input semantics and return fields. The presence of an output schema further reduces the need to document return values. Minor gaps such as pagination, result limits, or match behavior are not covered, but for a search endpoint this is adequately 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 fully explain the single 'q' parameter. It does: q is free text that can match creator name, CPID/asset name (e.g., NAMEDPEPE), stamp number, or a tx hash fragment. This gives the agent concrete guidance for constructing valid queries, fully compensating for the bare string 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: 'Search stamps by free text.' It enumerates the exact queryable fields (creator name, CPID/asset name, stamp number, tx hash fragment) and the returned fields, making it clear this is a free-text lookup tool rather than a list/get operation. The resource scope ('stamps') also separates it from sibling tools like search_src20.

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

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

The description gives clear context for when to use the tool: whenever the agent has a free-text fragment of a creator name, CPID/asset name, stamp number, or tx hash. It does not explicitly name alternatives or state when not to use it, but the query semantics strongly imply the right scenario, especially compared to list_stamps and get_stamp.

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 does not mention pagination behavior, rate limits, authentication requirements, or any side effects. It only describes the data shape, not how the tool behaves.

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 concise sentence that front-loads the core concept and then lists the fields. It is efficient, though the abbreviation 'pri' for pricing tiers adds mild ambiguity. No fluff or redundancy.

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

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

The description conveys the purpose and row contents, which is adequate for a list endpoint, especially given that an output schema exists. However, it omits usage context like pagination semantics or how this tool fits into the broader SRC-101 workflow. It is not completely inadequate but has clear gaps.

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

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

The schema description coverage is 0% and the description does not explain the page and limit parameters beyond what the schema already shows. The description enumerates output fields but provides no additional meaning for the input parameters, leaving the agent without guidance on how to use them effectively.

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 as SRC-101 deployments, gives a concrete example (BitNameService 'btc' names), and enumerates the row fields. It implicitly differentiates from sibling list_src20_deploys by naming the SRC-101 namespace, but it does not explicitly contrast them.

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

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

No guidance is given on when to use this tool versus alternatives like list_src20_deploys or get_src20. The description only defines the content, not the selection criteria or context in which this tool is preferred.

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 burden. It transparently states the two modes of operation, including the primary-name-first ordering for deploy_hash. It does not mention read-only nature explicitly, but that is implied. The description adds value beyond 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?

Two concise sentences, front-loaded with the main purpose, and no wasted words. Every sentence contributes to understanding the tool's behavior.

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 all functional aspects for a simple wallet lookup, and the presence of an output schema means return values need not be detailed. It is 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?

With schema description coverage at 0%, the description fully explains the semantics of both parameters: address as the holder and deploy_hash as the root filter. It adds crucial meaning that the schema lacks.

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 lists SRC-101 names held by an address, and explains the behavioral difference when deploy_hash is provided. This is specific and unambiguous, distinguishing it from sibling tools like src101_deploys.

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 describes when to use the tool with and without deploy_hash, giving clear conditions for each mode. While it doesn't compare against alternative tools, the context is sufficient for correct usage.

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 behavioral disclosure burden. It usefully states that amounts are token units and that tick is optional, but it does not mention pagination behavior, address format assumptions, or confirm that this is a read-only operation beyond the word 'balances.'

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

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

Two concise sentences with no filler. The main operation is front-loaded, and the decimals caveat is a valuable, compact addition.

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

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

For a read-only balance lookup with an output schema present, the description is nearly complete: it identifies the resource, optional filtering, and unit semantics. The main gap is the absence of explicit routing guidance among sibling balance tools.

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 add meaning to parameters. It clarifies 'address' as a Bitcoin address and 'tick' as optional single-tick filtering, but it leaves 'page' and 'limit' unexplained, relying on their names and defaults.

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 (SRC-20 token balances) and the target (a Bitcoin address), and distinguishes all-ticks versus one-tick behavior. It lacks an explicit verb like 'returns' and does not name sibling tools, but the purpose 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 intended use is implied: query SRC-20 balances for an address, optionally filtered to one tick. However, it does not explicitly compare against siblings such as src20_holders or wallet_balance, nor state when not to use this 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 full burden for behavioral disclosure. It states the snapshot is at the current block and that results are ordered by amount descending. It does not mention pagination behavior, rate limits, or any potential side effects, but for a read-only snapshot tool these are minor gaps.

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

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

Two sentences, no filler, with the core behavior first and the use case second. Every word earns its place, and the structure is ideal for quick agent 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?

An output schema exists, so return-value documentation is covered. The description covers the essential inputs (tick) and the use case, and the pagination defaults are in the schema. For a simple snapshot tool, it is sufficiently complete, though it could mention that the result may be paginated.

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 clarifies that 'tick' is the SRC-20 identifier, but it does not explain 'page' or 'limit' beyond the schema's defaults. Since these are standard pagination parameters, the lack of explanation is a modest but real gap.

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

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

The description states a specific verb ('snapshot'), a precise resource ('SRC-20 tick'), and the output ordering ('largest first'). It clearly distinguishes itself from sibling tools like stamp_holders (for stamps) and src20_balance (single-address balance) by focusing on holder distribution for a tick.

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 a clear use case ('concentration checks (top-10 share)') which tells the agent when to apply this tool. It does not explicitly name alternatives or exclusions, but the purpose is specific enough to route correctly among siblings.

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 is transparent about the unreliable nature of multi-period volumes upstream, often returning 0, which is a valuable caveat. It also explains that without tick the result is a ranked list, implying an ordered response. However, it does not mention pagination behavior (beyond page/limit parameters), rate limits, or any potential side effects, though as a read operation this is minor.

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

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

The description is dense but efficient, front-loading the purpose and behavior. It uses a compact list of fields and a clear conditional structure. Every sentence adds value, though it could be slightly more concise by trimming the exhaustive field list, but it remains readable and well-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 the tool's moderate complexity, an output schema exists (though not shown), which presumably documents return fields. The description covers the core behavior, the data quality caveat, and the sort options. It does not explicitly explain how to interpret data_quality_score or pagination details, but these are likely covered by the output schema. The description is sufficiently complete for an agent to invoke the 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 input schema has 0% description coverage, so the description must compensate. It thoroughly explains the tick parameter (with/without behavior) and the sort options (market_cap_usd, volume_24h_btc, price_change_24h_percent) and mentions order asc/desc. It does not explicitly describe page or limit, but these are self-explanatory and have defaults. The description adds significant meaning to the non-trivial 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 clearly states the resource (SRC-20 market data) and its dual behavior: with a tick it returns that token's market data, without it returns a ranked list. It enumerates the available sort keys and fields, which fully differentiates it from sibling tools like get_src20 or list_src20_deploys that serve different purposes (individual token details vs market rankings).

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 context through the behavioral distinction (with/without tick) and the sort options, making it clear when to use this tool for market data. However, it does not explicitly mention alternatives or state when not to use it, relying on the sibling names to hint at alternatives. No direct exclusions or comparisons 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, the description carries the burden of behavior. It discloses the transaction types, ordering (newest first), filterable parameters, and output fields (creator, destination, amt, tick, stamp number, block_time). It omits pagination semantics and error handling, but provides solid transparency for a read-only list tool.

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

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

Two sentences, front-loaded with purpose, no redundancy. Every sentence adds value: what it returns, ordering, filters, and row contents. Efficient and well-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 an output schema exists, the return format is covered. The description covers the core behavior and filters. It does not mention pagination defaults (page/limit) or behavior when no results, but those are minor for a filtered list tool. Overall, complete enough for an agent to call it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It explains the meaning of tick, op, and block_index as filters, and mentions output fields. It does not elaborate on page/limit (though these are common) or the exact allowed values for op (though the description lists them). Partial compensation, not exhaustive.

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 returns valid SRC-20 transactions (DEPLOY/MINT/TRANSFER) newest first, and lists filterable fields. It is specific and not a tautology, but does not explicitly differentiate from sibling tools like src20_tx or search_src20, so it falls short of a 5.

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

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

The description implies usage: listing and filtering transactions. However, it does not mention when to prefer this over siblings (e.g., src20_tx for a single transaction) or when not to use it. Guidance 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 carries the behavioral burden. 'Decode' suggests a safe, read-only operation and the field list clarifies what is returned, but it does not disclose behavior for missing or malformed hashes, validity semantics, or any side effects. Adequate for a simple lookup, but not richly 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?

One concise sentence front-loads the action and resource, then efficiently lists the decoded fields after a colon. There is no redundancy or filler, so every word contributes to understanding the 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 the simple single-parameter schema and the presence of an output schema, the description is complete enough: it identifies the input, the operation, and the key result fields. It does not need to explain return values further because the output schema covers structure.

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

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

The schema has no parameter descriptions, but the description clarifies that tx_hash is the Bitcoin transaction hash used to decode the SRC-20 transaction. This adds real meaning beyond the bare parameter name, even though it does not specify format details like hex length.

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 ('Decode') and a clear resource ('one SRC-20 transaction') with the lookup key ('by its Bitcoin tx hash'). It also lists the returned fields, which makes the tool's purpose unmistakable and distinguishes it from sibling tools like src20_transactions or src20_balance.

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 about when to prefer this tool over alternatives or when not to use it. The description implies a hash-lookup use case but never states it explicitly or names sibling tools that might be more appropriate for listing or searching.

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 to lean on, the description carries the behavioral burden. It adds concrete semantic detail: what sends and dispenses mean, the fact that dispenses include BTC paid, and that results are newest-first. It doesn't mention read-only safety explicitly, but 'history' implicitly indicates a 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 one tight sentence, front-loads the resource and action, then packs kind semantics and ordering into the remaining clauses. No filler or repetition.

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

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

For a simple read-only history endpoint with an output schema, the description covers the essential behavior and ordering. It omits explicit pagination semantics and sibling routing, but the output schema plus parameter defaults reduce the need for further explanation.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains 'kind', but says nothing about 'stamp_id', 'page', or 'limit'. The names/defaults provide some structure, but the tool definition leaves most parameter semantics to inference.

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 ('stamp') and the operation ('transfer history'), and further differentiates sends from dispenses. It doesn't explicitly contrast with sibling tools, so it falls just short of a perfect score.

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?

By saying 'transfer history for a stamp' and defining kind='sends' vs kind='dispenses', the description gives clear context for when this tool fits: to inspect a stamp's transfer/send or dispense activity. It does not name alternatives or exclusions, but the context is unambiguous enough for selection among the listed siblings.

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 lists what the tool reports (API, DB, mempool, XCP status, sync state, stamp counts, circuit-breaker state), giving a clear picture of its read-only nature, though it does not explicitly state 'read-only' or describe potential side effects. Since it's a health status query, the absence of side-effect disclosure is acceptable, but a minor gap remains.

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 one sentence, front-loaded with the core purpose ('Health of stampchain.io and its indexer'), followed by a colon and a concise list of key metrics. Every phrase adds value, with no fluff or repetition. The 'Call first if other tools error' advice is a useful addition at the end. This is optimal for an agent scanning quickly.

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

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

Given the tool has no parameters and an output schema exists (not shown but indicated), the description is complete for its purpose. It specifies all the conceptual data points an agent would expect, and the usage guidance is explicit. There is nothing missing that would prevent correct invocation or interpretation of the tool's role.

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

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

There are zero parameters, so the schema is empty and provides no semantic meaning. Per the guideline, a 0-parameter tool starts at baseline 4. The description does not need to elaborate on parameters, and it doesn't; it focuses on the output and usage, which is appropriate. The baseline score stands because the description adds no confusion.

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's purpose: checking the health of stampchain.io and its indexer, listing specific data points like API/DB/mempool status, sync state, and circuit-breaker state. It uses a specific noun and verb ('Health of stampchain.io...') and distinguishes itself from sibling tools, which are all data retrieval operations on stamps/blocks, not a status check.

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

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

The description explicitly states when to use it: 'Call first if other tools error.' This provides a clear situational trigger and implies a diagnostic role. It also lists the high-level categories of information it returns, so an agent knows exactly when this tool is appropriate. No exclusion criteria are needed for a general health check.

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 clearly states the tool only reads and explains the meaning of open/closed and the floor price, which is useful. Yet it omits details like pagination behavior, error conditions, or permission requirements, making the transparency adequate but not 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 single paragraph that front-loads the main purpose and then explains the data fields and key concepts. It is concise with no filler, though it could be tightened by trimming redundant phrasing like 'the on-chain listings' after already saying Counterparty dispensers.

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 three parameters and an output schema, the description covers the return data and the read-only nature, but lacks guidance on parameter usage, sibling differentiation, and edge cases (e.g., pagination limits, error handling). These gaps prevent it from being fully complete.

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

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

The schema description coverage is 0%, meaning the description does not explain any of the three parameters (stamp_id, page, limit). While stamp_id is implicitly referenced as 'for a stamp', the description does not define the parameter semantics or provide additional meaning beyond the schema's names and types, failing to compensate for the coverage gap.

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

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

The description clearly states the tool lists Counterparty dispensers for a stamp, describing them as on-chain listings and enumerating the fields returned. It conveys the specific resource (dispensers) and the entity (stamp), but does not explicitly differentiate it from sibling tools like dispensers_by_address or stamp_holders, so it loses a point.

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

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

The description implies usage for reading dispenser listings and explicitly notes that buying is a wallet action, not this tool. However, it does not mention alternatives or conditions for when to choose this tool over others, leaving the agent to infer the use case from the name and 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It does not mention pagination behavior (despite page/limit parameters), error handling, required permissions, or the return format beyond the fields listed. The second sentence about supply is domain context, not tool 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 concise, with the core purpose in the first sentence and supplementary context in the second. It is front-loaded and avoids redundancy. The second sentence, while useful domain info, could be trimmed without losing essential functionality.

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 a required parameter and pagination options, the description is incomplete. It does not explain how to specify the stamp_id, what the output schema entails, or how pagination works. The presence of an output schema partially mitigates the return format gap, but input parameter guidance is missing.

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

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

Schema description coverage is 0%, and the description does not compensate. It fails to explain that stamp_id is required, or what page and limit control. No parameter meanings are conveyed beyond the schema's bare types and defaults.

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 resource (stamp holders) and the information returned (address, amount held, percentage of supply). The verb is implied but evident from 'Who holds'. It distinguishes itself from siblings like wallet_stamps and src20_holders by focusing on a single stamp's holder distribution, but does not explicitly name alternatives.

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: to find who holds a stamp. It provides domain context about supply (art stamps vs. SRC-721/editioned) but does not explicitly state when to use this tool over alternatives like get_stamp or wallet_stamps, nor when not to use it.

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 the behavioral burden. It discloses a non-obvious default: omitting block_index selects the latest indexed block, which the schema's default null does not convey. It does not discuss empty-block or invalid-block behavior, but for a simple block-scoped read this is adequate.

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

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

Two sentences with no filler. The core behavior is front-loaded, and the use-case phrase at the end earns its place by giving the agent a quick reason to select this 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 one optional parameter, an existing output schema, and a simple read-only purpose, the description is complete enough for correct selection and invocation. The only nuance an agent needs—what happens when block_index is omitted—is explicitly stated.

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

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

Schema coverage is 0%, so the description must compensate. It adds real meaning by explaining that the omitted/null block_index means 'latest indexed block', which is the key semantic for the single parameter. It could also clarify behavior for unknown block indices, but the core parameter behavior is 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?

Description states a specific verb-plus-resource: 'Stamps minted in a block', and distinguishes itself by scoping to block membership. It also clarifies the default behavior when block_index is omitted, which is far more than a restatement of the 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 phrase 'the latest indexed block when block_index is omitted' gives clear context for the common call pattern, and 'Good for what just got stamped' points to a concrete use case. It does not name sibling alternatives explicitly or give when-not-to-use conditions, so it stops short of a 5.

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

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

With no annotations, the description carries the full behavioral burden. It adds useful detail like 'with UTXO binding info' and the 'in one call' behavior, but it does not disclose pagination behavior, error handling, rate limits, or any side effects (though it is clearly read-only). The description is not contradictory, but it leaves significant behavioral aspects undocumented.

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, efficient sentence that front-loads the core purpose and includes the key differentiator ('in one call'). There is no filler or redundancy; every word contributes to understanding the tool's scope.

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?

While an output schema exists (though not shown), the description does not explain how the combined data is structured, how pagination applies across the different asset types, or what happens when an address has no stamps or tokens. It also omits prerequisites or error conditions. For a tool combining multiple data sources, this is too sparse to fully guide an 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?

Schema description coverage is 0%, so the description must explain the parameters. It only implicitly references 'address' via 'Bitcoin address' but gives no guidance on the 'page' and 'limit' parameters, their defaults, or their purpose (pagination). The agent receives no additional meaning beyond the raw schema, failing to compensate for the lack of schema descriptions.

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

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

The description clearly states the tool's function: a combined view of a Bitcoin address returning BTC balance, stamps with UTXO binding info, and SRC-20 balances in one call. The verb 'view' and specific resource and data types distinguish it from sibling tools like wallet_stamps or src20_balance, which focus on a single asset class.

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 it (when you need all three data types together) via 'combined view' and 'in one call', but it does not explicitly mention alternatives or exclusions. There is no guidance on when to prefer a more specific tool for only one asset type, leaving the choice to inference.

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

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

With no annotations, the description carries the behavioral disclosure burden. It usefully states that value is included 'when available' and that results are 'enhanced with market data by default.' However, it does not mention pagination behavior, address validity requirements, or any operational limits.

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 concise and front-loaded with the core purpose. The sort options are packed into a parenthetical that is efficient, though the trailing '...' introduces some ambiguity about supported values.

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 presence of an output schema reduces the need to describe return values. Still, the description omits usage alternatives and leaves most parameter semantics undocumented. It is adequate for a simple address-scoped lookup 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 description coverage is 0%, so the description must compensate for all parameters. It partially documents sort_by with a list of allowed values, but it leaves page, limit, and address format unexplained. Only one of four parameters receives meaningful new 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: stamps held by a Bitcoin address, including per-stamp balance and optional value. It distinguishes itself from siblings like wallet_balance and stamp_holders by the address-scoped, per-stamp view with market data, though it lacks an explicit verb like 'list' or 'retrieve'.

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 about when to use this tool versus alternatives such as wallet_balance, stamp_holders, or list_stamps. The context is implied by the address scope, but there are no explicit conditions, exclusions, or routing hints.

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