Satoshidata Wallet Intel

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 describes the report structure, lists included and optional components, and clearly states what the tool does NOT provide (score, verdict, etc.). This adds meaningful behavioral context beyond the schema, such as the conditional nature of risk_check and flow graph, though it leaves some terms (e.g., 'component statuses') undefined.

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 three sentences, front-loaded with the main purpose, followed by a list of contents and a clear exclusion. Every sentence earns its place, with no redundant or vague filler. It is concise yet informative.

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

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

The tool has an output schema, so return values are structured, and the description provides a clear overview of the report's composition and limitations. It covers the key aspects: what the report includes, what it excludes, and optional components. However, it does not explicitly differentiate from all siblings or explain terms like 'component statuses,' which slightly reduces completeness for an agent navigating many similar address-related 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 100%, so the baseline is 3. The description adds semantic value by linking parameters to report sections: 'optional flow graph' maps to include_graph and depth, and 'recent transactions' maps to tx_limit. This helps the agent understand how parameters shape the output, going slightly beyond the schema definitions.

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: 'Return a free sectioned evidence report for one Bitcoin address.' It specifies the resource (one Bitcoin address) and the deliverable (evidence report), and lists contents (labels, trust-safety, risk signals, overview, recent transactions, flow graph). It also distinguishes from scoring/verdict tools by stating 'Evidence only: no score, verdict, clearance, or compliance recommendation.'

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 for when to use this tool (when an evidence report for a single address is needed) and explicitly limits its scope ('no score, verdict, clearance, or compliance recommendation'), implying alternatives for those needs. However, it does not name specific sibling tools like 'address_risk' or 'risk_check' as alternatives, so it stops short of explicit when-not guidance with 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 full burden but only reveals the output composition, not behavioral traits like whether the call is read-only, premium costs, data latency, or error handling. It does not mention any side effects or access constraints, so the agent lacks safety and expectation-setting 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 a single, front-loaded sentence that names the action, resource, and key output components efficiently. Every phrase carries meaningful information without fluff, making it easy to parse.

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 the tool has an output schema and a simple parameter, the description doesn't address why one would choose this 'premium' card over similar address tools, nor does it mention any operational constraints (rate limits, cost, data freshness). It is adequate for understanding the return shape but not richly contextual for selection among siblings.

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

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

The input schema already fully describes the single 'address' parameter with a clear definition ('Bitcoin wallet address to enrich'), covering 100% of the schema. The description adds no additional parameter semantics beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Return') and the specific resource (the premium address-intelligence card) with detailed content types (best label, live wallet activity, cohort hints, scanner signals), distinguishing it from generic address tools. The inclusion of 'single Bitcoin address' clarifies 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 gives no guidance on when to use this tool versus the many sibling tools like address_risk or address_evidence_pack. It does not state exclusions, prerequisites, or preferability conditions, leaving the agent to infer applicability from the output card contents 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 burden of behavioral disclosure. It does disclose the informational nature, bounded flags, coarse risk indicator, and non-advice caveat. However, it does not explicitly state whether the operation is read-only, mention data freshness, or address any side effects, leaving some 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, front-loaded with the core purpose and output components, and ends with an essential disclaimer. Every sentence contributes value with no unnecessary information.

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

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

An output schema exists, so return values are likely detailed there. The description adds context about output categories and limitations. However, it lacks usage guidance and parameter specifics, making it only partially complete for a tool with one parameter and no annotation support.

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, 'address', has no description in the schema (0% coverage) and the tool description adds no additional meaning beyond the parameter name. It does not specify accepted address formats, networks, or examples, so the agent gains no extra semantic information from the description.

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 factual address risk signals and lists specific output components (entity label/category, source count, bounded behavioral flags, coarse risk_indicator, disclaimer). This distinguishes it from siblings like risk_check by emphasizing 'coarse' and 'factual' outputs.

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 legal disclaimer ('not AML/KYT/compliance advice') but gives no explicit guidance on when to use this tool versus alternatives like risk_check or address_intelligence. There is no mention of appropriate use cases or exclusions beyond the disclaimer.

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 of behavioral disclosure. It adds useful context about forwarding X-WR-API-Key/Bearer auth when present, which is beyond the schema. However, it does not explicitly state that the tool is read-only, discuss error handling, or mention rate limits, 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?

The description consists of two concise sentences that front-load the primary purpose. Every word earns its place, with no fluff 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?

The tool is simple (one parameter) with full schema coverage and an output schema, which offloads return-value details. The description covers the core purpose and the auth forwarding nuance, making it fairly complete. It could have explicitly mentioned that this is the batch counterpart to 'address_intelligence', but the name and context signals make that apparent.

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 100% coverage for the single parameter 'addresses', including a description of 'Bitcoin addresses to enrich, in result order.' The tool description does not add any additional parameter semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states a specific verb ('Return') and resource ('satoshidata.ai address-intelligence cards') for multiple Bitcoin addresses. It distinguishes itself from singular tools like 'address_intelligence' and other batch tools by explicitly mentioning 'multiple' and 'in one call'.

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 for when to use the tool: when you need address-intelligence cards for multiple addresses in one call. It does not explicitly mention alternatives or exclusions, but the context is clear enough that an agent could infer when this batching tool is appropriate.

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 partially carries the transparency burden. It discloses the auth forwarding behavior and the 'factual label-derived' nature, but does not mention output format, rate limits, or side effects (though likely a read operation). This adds some context but lacks richer behavioral detail.

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, each purposeful. The first states the core function, the second provides auth behavior. No filler or redundancy; front-loaded with the essential purpose.

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 parameter and an output schema, so the description sufficiently covers purpose and auth forwarding. It could benefit from explicit alternative tool references, but overall the description is adequate for the tool's 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?

Schema coverage is 100% with address descriptions already explaining the parameter ('Bitcoin addresses to score, in result order'). The description adds no new semantic information beyond reinforcing 'multiple,' so a baseline 3 is appropriate.

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

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

The description clearly states the tool returns 'factual label-derived risk indicators' for 'multiple Bitcoin addresses in one call,' specifying the resource and batch nature. This distinguishes it from single-address risk tools and other batch tools by emphasizing the label-derived aspect.

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 multiple addresses needing risk assessment in one call, but does not explicitly name alternatives or state when not to use it. The batch context is clear, but no exclusions or comparisons to similar sibling tools like risk_check_batch 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 for behavioral disclosure. It does add context about forwarding X-WR-API-Key/Bearer auth when present, which is useful. Yet it omits other important behaviors such as whether the operation is read-only, how invalid addresses are handled, or any rate limits, leaving significant 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 exactly two sentences with no redundant words. It front-loads the core purpose and then adds a concise, useful note about auth forwarding, making it highly efficient.

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 existence of an output schema, return values need not be described. However, with no annotations, the description should still cover key operational constraints. It does not mention batch size limits, partial failure behavior, or any prerequisites, leaving the description adequate but with 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 input schema already provides 100% coverage with a description for the 'addresses' parameter, including 'Bitcoin addresses to summarize, in result order.' The tool description adds no new meaning beyond repeating 'multiple Bitcoin addresses' and 'in one call,' so a baseline score of 3 is appropriate.

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

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

The description clearly states it 'Return[s] satoshidata.ai wallet/entity summaries for multiple Bitcoin addresses in one call,' specifying the verb, resource, and scope. This distinguishes it from sibling tools like batch_intelligence and batch_risk_signals by naming the exact data type (wallet/entity summaries).

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 'for multiple Bitcoin addresses in one call' implies usage when a batch of summaries is needed, providing clear context. However, it does not explicitly mention alternatives (e.g., wallet_summary for single addresses) or 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool 'forwards X-WR-API-Key/Bearer auth when present' and returns the REST payload, which go beyond the schema. The term 'look up' implies a read-only operation, providing adequate safety transparency for a lookup 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?

The description is two sentences: the first states purpose, the second covers return format and auth forwarding. Every word is informative, with no redundancy or fluff, and the key information 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 single-parameter batch lookup tool with an output schema, the description covers purpose, batching, return payload, and auth behavior. It does not mention potential batch size limits or compare against siblings, but it is sufficiently complete for selection and 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 100%, with the 'addresses' parameter already described as 'Bitcoin addresses to look up, in result order.' The tool description adds no additional parameter-level details, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Look up labels and trust-safety signals for multiple Bitcoin addresses in one call.' It specifies a verb ('look up'), a resource ('labels and trust-safety signals'), and scope ('multiple Bitcoin addresses'), distinguishing it from sibling tools like batch_risk_signals and batch_intelligence.

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 'in one call' clearly indicates this tool is for batch lookups of multiple addresses, contrasting with single-address tools. While it doesn't explicitly name alternatives or state when not to use it, the context is clear enough for an agent to infer the appropriate 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 provided, the description carries the full burden for behavioral disclosure. It reveals the data source (satoshidata.ai) and the fact that it returns a snapshot and 24h change, which is honest but minimal. It does not mention data freshness, potential delays, or what happens if the source is unavailable, but for a simple read-only price lookup, this level of transparency is acceptable.

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 with no filler. It front-loads the key action ('Return') and details the exact output in under 20 words. Every word 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 parameterless tool with an output schema present, the description provides the essential context: what data is returned and from where. It could optionally clarify the currency (e.g., USD) but the description is largely sufficient given the output schema handles return-value details. Slightly more context about refresh rate or source reliability would push this higher.

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 schema already covers this fully (100% coverage), and the description adds no irrelevant parameter details. There is nothing else needed for 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 uses a specific verb 'Return' with a clear resource: 'current Bitcoin price snapshot and 24 hour change'. It explicitly states the data source and distinguishes the tool from siblings focused on blockchain analytics, addresses, and mempool stats. This leaves 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 implies usage for retrieving current Bitcoin price and 24h change, but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. Given the context of many sibling tools, some explicit comparison would strengthen this dimension, but the purpose is clear enough to infer typical 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's 'Return' indicates a read-only operation. It adds behavioral details like 'coinbase attribution' and 'transaction sample' (not all transactions), which are important. Does not mention rate limits or error behavior, but is adequate for a read 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?

Single sentence, front-loaded with the verb, and contains no filler. Every word contributes to the tool's purpose.

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 simplicity (one param), the description covers the key output categories. The presence of an output schema covers return structure. It doesn't discuss error handling or alternatives, but this is a minor gap for such a straightforward 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?

The schema provides only a string param with title 'Height Or Hash' and no description. The description's 'for a height or block hash' explains the parameter's accepted values, compensating for the 0% schema coverage. It clarifies that the string can be either a block height or hash.

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 it returns Bitcoin block metadata, coinbase attribution, and a transaction sample. The verb 'Return' specifies the action and 'for a height or block hash' defines the input scope. This distinguishes it from sibling tools which focus on addresses, pools, or wallets.

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 block-level detail is needed, but does not explicitly contrast with alternatives or state when not to use. Since no direct sibling for block details exists, the context is clear enough. Lacks exclusions or prerequisite 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 the burden of behavioral disclosure. It adds a useful note about forwarding Wallet+ Bearer or x402 payment headers, indicating authentication/payment behavior. However, it does not mention read-only behavior, rate limits, or pagination traits, leaving 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 a single sentence that packs the core purpose and key behavioral note without redundancy. Every clause contributes meaning, making it efficient and easy to parse.

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

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

The tool has a rich input schema and an output schema, so the description does not need to explain return values. It covers the primary purpose, filter categories, and header forwarding. It slightly lacks context on what constitutes an 'awakening event', but overall is adequate given the structured metadata.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters. The description briefly summarizes filters (dormancy age, BTC value, window bounds, limit) but adds no new semantic detail beyond what the schema provides, aligning with the baseline.

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

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

The description clearly states the tool returns dormant-coin awakening events over a bounded window, specifying the resource and action. It does not explicitly distinguish from related siblings like dormancy_flushes or pulse_dormant, but the focused phrasing 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?

No guidance is provided about when to use this tool versus alternatives, nor any exclusions or prerequisites. The description implies usage for querying dormant-coin events but does not help an agent choose between this and similar 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?

No annotations are present, so the description must disclose behavioral traits. It only states the return type and classifications, without explaining the default limit, time window, or meaning of 'CMCS'. The read-only nature is implied but not explicitly confirmed, and there is no mention of edge cases or performance characteristics.

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, clear sentence that front-loads the tool's purpose. It is concise with no redundant 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?

The tool has three optional parameters, no annotations, and an output schema. The description fails to provide context about what 'dormancy awakenings' entails, what CMCS refers to, or how filtering works. Despite the output schema covering return values, the description lacks sufficient context for an agent to determine when to invoke it amid sibling 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?

The schema has no descriptions for any parameters. The description helps clarify the 'classification' parameter by enumerating valid categories, but it provides no explanation for 'limit' or 'since'. Thus, the description adds some value for one parameter but leaves the others unexplained.

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 'Return' and identifies the resource as 'CMCS dormancy awakenings' with classification into four categories. This clearly defines the tool's function. However, it doesn't explicitly distinguish it from sibling tools like chain_awakenings, so it's not 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?

No usage guidance is provided. The description doesn't indicate when to use this tool versus alternatives or any prerequisites. It only states what the tool does, leaving the agent to infer applicability.

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 of behavioral disclosure. It states that the tool 'returns' data, implying a read-only operation, but does not disclose any side effects, data characteristics, or potential limitations. There is no mention of pagination, freshness, or other behavioral traits beyond the return of categories and counts.

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, clear sentence that is front-loaded with the verb 'Return' and the resource. Every word contributes to understanding the tool's purpose, with no unnecessary detail 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?

The tool is simple with no parameters and has an output schema, so the description only needs to convey the high-level return contents. However, without annotations or usage guidance, and given the large set of sibling tools, an agent may not fully understand when to call this tool or what 'coverage_status distributions' means in practice. The description 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?

The tool has zero parameters, so the schema provides complete coverage (100%) and no parameters need explanation. The description adds meaning about the nature of the returned data (categories, counts, coverage_status), which is consistent with the baseline of 4 for parameterless tools.

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 'Return' and clearly identifies the resource: 'Bitcoin entity rollup categories' along with the output contents (counts, coverage_status distributions). This distinguishes it from sibling tools like entity_list and entity_lookup, which deal with individual entities rather than categories.

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 no guidance on when to use this tool versus alternatives such as entity_list or entity_lookup. It does not mention exclusions or context in which this tool is preferred, leaving the agent to infer usage from the name and description 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 provided, the description carries the transparency burden. It adds useful context by clarifying that coverage_status indicates coverage levels and that last_activity_at refers to label-DB activity, not on-chain transaction time. However, it does not disclose other behavioral traits (e.g., pagination, rate limits) beyond schema details.

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: the first clearly states the main function, and the second clarifies important return-field semantics. Every sentence adds value, and there is 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 the tool has only three optional parameters and an output schema, the description covers the essential purpose and field clarifications, making it largely complete. It lacks usage guidance, but that is addressed in the usage_guidelines dimension.

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

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

Schema description coverage is 100% for all three parameters, so the schema already provides full semantics. The description adds no additional parameter meaning beyond reinforcing category as an optional filter, which is already documented in the schema.

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

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

The description clearly states the action ('Return') and specific resource ('named Bitcoin entity rollups'), which immediately distinguishes it from related tools like entity_lookup (single entity) and entity_categories (just category listings). The optional category filter is also mentioned.

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 on when to use this tool versus alternatives (e.g., entity_lookup or entity_categories). The description only says 'optionally filtered by category,' which implies a use case but does not state exclusions or naming 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 of behavioral disclosure. It adds valuable caveats: coverage_status explains different levels of completeness, and last_activity_at is clarified as label-DB activity, not on-chain time. It also discloses that the member-address list is only a bounded sample, giving the agent crucial expectations about the data. It does not mention error cases or autf requirements, but the disclosed semantics are genuinely informative.

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; the first states the core function, the second adds two essential clarifications about output fields. No fluff, every word contributes to 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?

Given the presence of an output schema (which can document return fields), the description appropriately highlights non-obvious aspects like coverage_status meanings and the distinction of last_activity_at. It also communicates the sampling behavior. It could mention error handling or whether the entity must exist, but for a simple lookup tool this is reasonably 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?

Input schema property descriptions cover 0% of the parameters, so the description must compensate. It only hints at member_limit via 'bounded sample' and does not explicitly describe either parameter. entity_name is self-explanatory from context, but member_limit's role and default are left to the schema (which lacks descriptions). The description adds minimal semantic value for the 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 tool returns a rollup for one named Bitcoin entity plus a bounded sample of member addresses. It distinguishes the tool from siblings like entity_list by emphasizing 'one named' entity and the 'bounded' sample, making its specific role clear.

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 when you need a single entity's rollup, but it does not explicitly state when to choose this over alternatives like entity_list or batch intelligence. There are no exclusions or comparisons, so the guidance is only implicit.

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

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

With no annotations, the description carries full responsibility for disclosing behavior. It only adds 'bounded' and 'small named entity,' which is vague. It does not mention rate limits, error conditions, whether activity includes transactions and/or balances, or what 'bounded' concretely means (e.g., limit or time range).

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, direct sentence with no fluff, which is concise. However, it is so sparse that it fails to provide valuable detail, and the structure does not incrementally reveal scope or constraints.

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 an output schema exists, the tool has no annotations and the description is minimal. It doesn't clarify what 'activity' includes, what 'small' means, or how the 'since' and 'limit' parameters interact. The description is incomplete for safe and correct usage.

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 any of the three parameters (entity_name, limit, since). The schema itself only provides titles, so the agent has no additional semantic guidance beyond the parameter names.

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 ('Return') and names a distinct resource ('recent on-chain activity sample for a small named Bitcoin entity'), which clearly distinguishes it from address- or entity-lookup tools. However, 'bounded' is vague and not fully defined, slightly reducing 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?

No explicit guidance is provided on when to use this tool versus alternatives like entity_lookup or wallet_summary. The phrase 'recent activity sample' implies a quick-scope use case, but no alternative tools or exclusions are mentioned.

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 of disclosing behavior. It does add the external source (satoshidata.ai) and indicates the data is 'current', which is useful context. It lacks details about freshness guarantees or potential network dependency, but for a simple read-only query 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?

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to specifying the tool's purpose and data source.

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?

This is a very low-complexity tool with zero parameters and an output schema present. The description provides the core purpose and source, which is sufficient for a tool of this simplicity; return values are already documented by the 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?

The input schema has zero parameters, so schema coverage is complete. With no parameters to describe, the baseline of 4 applies; the description adds no parameter-related content because none is needed.

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: returning current recommended Bitcoin fee estimates. It identifies both the action ('Return') and the resource ('fee estimates from satoshidata.ai'), making it easily distinguishable from the broader set of sibling 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 is implied: use this tool when you need current recommended Bitcoin fee estimates. However, there is no explicit guidance on when this tool is preferred over alternatives like mempool_stats or onchain_stats, nor any exclusions or 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 the full burden of behavioral disclosure. It only states what is returned (size, fee floor, congestion summary) but does not disclose data freshness, caching behavior, potential cost or latency, or any additional traits beyond the purpose. For a simple stats tool, this is minimal 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 a single, front-loaded sentence that directly states what the tool does without any filler. Every word contributes to the purpose, achieving high conciseness and 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?

Given that the tool has no parameters and an output schema exists, the description need not detail return values. It covers the key aspects of the tool (size, fee floor, congestion) sufficiently for a zero-parameter snapshot. The only minor gap is that 'congestion summary' is somewhat vague, but the output schema should clarify this.

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 schema coverage is trivially complete and there is no need to document parameter meanings. The baseline for zero parameters is 4, and the description adds no unnecessary parameter details.

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 ('Return') and clearly identifies the resource: current Bitcoin mempool size, fee floor, and congestion summary. It distinguishes from siblings like fees_recommended or mempool_tx by focusing on aggregate stats rather than specific fee levels or transactions.

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 but not explicitly stated. The description indicates this tool provides a current mempool snapshot, suggesting it should be used when an overall mempool overview is needed rather than fee recommendations or individual transaction data. However, no explicit 'when not to use' or comparison with alternatives is 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 provides useful behavioral context by disclosing that it forwards Wallet+ Bearer or x402 payment headers when present, and explains the premium upgrade conditions via include_components or history_hours. This adds non-obvious access tier information, though it omits rate limits or error cases.

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, well-structured sentence that front-loads the main purpose and packs in parameter usage and header-forwarding behavior without unnecessary words.

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 parameters and an output schema, the description covers the purpose, parameter effects, premium options, and header forwarding. It omits edge cases like invalid history_hours, but the range is given and the output schema handles return format.

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 0% description coverage, but the description adds meaning by explaining that include_components=true requests the Premium component payload and history_hours=1-168 requests the history payload with a valid range. This compensates well for the minimal 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 the tool returns the current mempool-stress index, a specific resource distinct from sibling tools like mempool_stats or mempool_tx. The optional parameters are mentioned, reinforcing the 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 description does not explicitly compare against alternatives or state when to use this tool over other mempool tools. It provides configuration guidance for the premium payload, but no when-to-use versus 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 full burden for behavioral disclosure. 'Inspect' implies a read-only operation, but it doesn't state whether the tool can fail (e.g., if txid is not in mempool), whether it handles confirmed transactions differently, or what side effects (if any) exist. No mention of rate limits or data freshness.

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 sentence with no fluff, front-loading the action and target. It is appropriately sized for the tool's simplicity and contains no redundant information. Every word 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 tool is simple (one parameter) and an output schema exists, which likely describes return values. However, with no annotations and no parameter semantics, the description is minimal but sufficient for basic invocation. It lacks context about edge cases (e.g., confirmed transactions, invalid txids) and usage prerequisites, making it adequate but with 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 input schema has one required parameter (txid) with no description, and the tool description provides zero information about it. With 0% schema description coverage, the description should compensate, but it doesn't explain what a txid is, its format, or how to obtain it. The parameter is completely unexplained.

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 ('Inspect') and resource ('a single unconfirmed Bitcoin transaction currently in the mempool'), making its scope clear. This distinguishes it from sibling tools like mempool_stats (which covers stats) and tx_status (which likely handles confirmed transactions). The phrase 'currently in the mempool' reinforces the unconfirmed scope without ambiguity.

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

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

No when-to-use guidance or alternative tools are mentioned. The description implies it's for unconfirmed mempool transactions, but it doesn't explicitly state when to use this over tx_status, tx_verify, or other sibling tools. There is no exclusion of confirmed transactions or mention of prerequisites.

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?

There are no annotations, so the description carries the burden of behavioral disclosure. It does disclose the routing behavior (block identifiers use /v1/blocks, etc.) and hints that pool names must be 'known' and addresses are 'candidate payout addresses'. However, it does not disclose whether exactly one parameter must be provided, how conflicts are handled, or any failure modes. This is a moderate level of 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 two sentences, front-loaded with the purpose. The first sentence states the action and acceptable inputs; the second adds routing details. There is no redundant or missing 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?

Given the presence of an output schema and the description's coverage of purpose, parameters, and routing, the tool is largely well-documented. Minor gaps include the lack of explicit statement that only one lookup mode should be used at a time (though the 'or' implies it) and absence of error-condition information. Overall, it is complete enough for most lookup scenarios.

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 0% schema description coverage, the description fully compensates by explaining each parameter type: 'block height/hash' for block_height and block_hash, 'known pool name' for pool_name, and 'candidate payout address' for address. It also provides additional context about the underlying endpoints for each identifier type. This gives the agent a strong understanding of what each parameter means and how to choose among them.

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 returning mining-pool attribution with a specific verb 'Return' and resource 'mining-pool attribution'. It outlines three distinct lookup modes (block height/hash, pool name, address), which differentiates it from sibling tools like pool_detail or pool_list that focus on pool metadata rather than attribution.

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 on when to use the tool: whenever attribution by block identifier, pool name, or address is needed. It explains how different identifier types correspond to underlying endpoints. However, it does not explicitly name alternative tools or state exclusions, so it falls short of the highest score.

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 must carry the transparency burden. It discloses that charts are conditional and that the output is a summary, but it does not mention potential performance/latency implications of a combined call, data freshness, or any side effects. It is not misleading, but it is minimal.

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: the first states the core purpose, and the second gives precise parameter instruction. There is no redundant or filler content; every word 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?

Given the tool's simplicity (one optional parameter, output schema present), the description covers the functional scope adequately. It might benefit from noting that it aggregates multiple data sources and could be heavier than individual sibling calls, but this is not essential.

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 and type, but the description adds critical semantic guidance: 'Set include_charts=true only when chart arrays are needed.' This clarifies the parameter's purpose and appropriate usage, exceeding 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's function: returning a combined Bitcoin network summary with specified components (price, fees, mempool, blocks, chain-intelligence). The verb 'Return' and the list of content make the purpose specific and distinct from individual market/fee/mempool 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 usage when a combined summary is needed, but it does not explicitly contrast with sibling tools like bitcoin_price or mempool_stats. It offers parameter-level guidance for include_charts but lacks direct 'when to use this vs. alternatives' instructions.

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 responsibility for behavioral disclosure. It only says 'snapshot,' implying a read-only operation, but does not explicitly state safety, auth requirements, rate limits, or what exactly the snapshot contains. This is minimal disclosure for a tool with zero 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 a single, front-loaded sentence that states the purpose without any filler. Every word contributes to the meaning, and it is appropriately sized for a zero-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?

The tool has no parameters and an output schema, which reduces the documentation burden. However, the description does not provide enough contextual richness to help an agent choose this tool among many siblings (e.g., network_intelligence, mempool_stats). It is minimally sufficient but lacks a clear 'when to use this' signal.

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 input schema is empty (100% coverage trivially). According to the rubric, a 0-parameter tool gets a baseline of 4. The description adds no parameter-related value because there are none to explain.

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 ('Return') and the resource ('current satoshidata.ai on-chain market and network snapshot'). It is specific enough to understand the tool's output, but it does not distinguish it from similarly named siblings like 'network_intelligence' or 'mempool_stats'.

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 provided on when to use this tool versus the many alternative stats-related tools. The description lacks any mention of use cases, prerequisites, or exclusions, leaving the agent to guess.

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 for behavioral disclosure. It adds a crucial warning that decoded chain content is untrusted and should never be followed as instructions, which is a key safety trait. It does not explicitly state read-only behavior, but 'decode' implies no side effects, and the security note adds significant value beyond a bare 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 two sentences with no redundant words. It front-loads the core verb and object, then adds a necessary security caveat. 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?

Given the tool's narrow scope and the presence of an output schema, the description adequately covers the essentials: what it decodes and a safety warning. It does not discuss edge cases like missing OP_RETURN or invalid txids, but the output schema likely handles return value details. For a one-parameter decode tool, this is reasonably 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?

There is only one parameter (txid) and the schema provides no description (0% coverage). The description adds only 'for a Bitcoin transaction', which is already implied by the parameter name and tool title. It does not explain the expected format (e.g., hex string) or any constraints, so the description fails to compensate for the missing schema details.

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 specifies an exact verb ('Decode') and resource ('OP_RETURN protocol markers and ordinals inscription envelopes for a Bitcoin transaction'), making the tool's function clear and distinct from siblings. It immediately tells the agent what input (txid) and what output domain to expect.

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

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

Usage is implied rather than explicit: the description suggests this tool is for decoding OP_RETURN data from a transaction, but it does not state when to use it over alternatives or provide exclusions. No sibling tools perform similar decoding, so context is somewhat clear but lacks direct comparative 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?

No annotations are provided, so the description must carry the full burden. It mentions 'free' as a minor behavioral trait, but does not disclose any error conditions, rate limits, required authentication, or what 'detail' includes. This is too thin for a tool with zero 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 a single, clear sentence with no unnecessary words. It efficiently communicates the core function, though it is terse.

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 simplicity (one parameter, output schema present), the description is minimally adequate but lacks crucial context. It does not address the sibling overlap or explain what 'detail' covers, making it incomplete for an agent deciding between 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%, and the description only repeats the parameter's obvious meaning by saying 'for a named pool'. The schema already provides 'Pool Name' as the title, so the description adds no new understanding about the parameter's format, values, or 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 tool returns mining-pool detail for a named pool, using a specific verb ('Return') and resource ('mining-pool detail'). However, it does not distinguish from the sibling tool 'mining_pool_info', which likely serves a similar purpose, so it misses the differentiation that would 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 description provides no guidance on when to use this tool versus alternatives such as 'pool_list' or 'mining_pool_info'. It only states what it does, with no context, prerequisites, or 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, the description carries the full burden of behavioral disclosure. 'Return' implies a read-only operation, and 'free' indicates no payment requirement. However, it does not disclose potential limitations (e.g., how many pools, historical depth, or rate limits) or clarify what 'recent block-share windows' means operationally. It is adequate but not rich.

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 verb 'Return,' and every word adds value. It is concise and well-structured with 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?

Given the tool's simplicity (no parameters) and presence of an output schema, the description covers the essential points: what it returns and a qualifier ('free'). It could mention the output's scope more explicitly, but for a straightforward list tool, it is sufficiently 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?

This tool has zero parameters, so the baseline is 4. The description adds no parameter-specific meaning, but none is needed since the input schema is empty. The description's reference to 'free' and 'recent block-share windows' provides helpful context about the returned data.

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 a mining-pool roster, using the verb 'Return' and specifying the resource and additional detail about block-share windows. This distinguishes it from pool_detail and mining_pool_info, which focus on individual pools rather than a list. However, it does not explicitly name sibling tools, 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?

There is no guidance on when to use this tool versus alternatives. The description only mentions it is 'free,' which hints at availability but does not explain when one would choose pool_list over pool_detail or mining_pool_info. No exclusions or alternative tools 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?

No annotations are present, so the description carries the burden. It implies a read-only operation and adds a 'live' context, but does not disclose pagination, data formats, or edge cases. This is minimal but not misleading.

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 sentence, directly front-loaded with the verb 'Return', and no wasted words. Extremely concise 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?

The description is too brief for a tool with four optional parameters and no annotations. It does not explain what constitutes a consolidation candidate or how parameters affect results, and lacks context against sibling 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 coverage is 0% and the description does not explain any of the four parameters. Parameter names offer weak hints (e.g., limit, min_btc), but 'since' is ambiguous and no parameter semantics are clarified.

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 recent consolidation candidates from a named source (satoshidata.ai's Pulse feed). The specific resource (consolidation candidates) distinguishes it from sibling Pulse tools like pulse_whales or pulse_dormant.

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 provided about when to use this tool versus other pulse feeds or alternatives. There is no explicit context for selecting this tool beyond the basic description.

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 states the tool 'returns' data from a 'live' feed but does not disclose any limitations, authentication requirements, rate limits, pagination behavior, or whether results are real-time vs delayed. It adds minimal value beyond the obvious read-only nature implied by 'Return'.

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 sentence, front-loaded, and free of fluff. It is appropriately concise for a simple tool, though it sacrifices completeness by omitting parameter context.

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

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

Despite an output schema existing, the description fails to explain the meaning or usage of the four parameters, which control the scope of the returned data. With no schema-level descriptions, the tool is incomplete for an agent to invoke correctly 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%, and the description does not mention any of the four parameters (limit, since, min_btc, min_age_years). The description adds no meaning beyond the input schema, which itself lacks descriptions. This is a significant gap for a tool with multiple optional 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 uses a specific verb ('Return') and a clear resource ('recent dormant-coin reactivations') sourced from a named feed (satoshidata.ai's live on-chain Pulse feed). This makes the tool's purpose clear and distinct from many siblings, though it does not explicitly differentiate from closely related tools like chain_awakenings or dormancy_flushes.

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: you would use this tool when you need recent dormant-coin reactivation data. However, it provides no explicit alternatives, exclusions, or when-to-use guidance beyond the evident purpose. The context is clear but not elaborated.

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 must carry the transparency burden. It only states what is returned ('health and 24-hour event totals') but does not clarify what 'health' includes, data freshness, or any caveats. This is minimal and leaves significant room for ambiguity.

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 front-loaded sentence with no wasted words. It immediately states the target and the output 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?

For a zero-parameter tool with an output schema, the description adequately identifies the purpose and basic scope. However, 'health' is vague and the distinction from sibling pulse tools is not reinforced, leaving some contextual 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 tool has zero parameters, so the schema already fully describes invocation. Per the rubric, a zero-parameter tool receives a baseline of 4; the description does not need to add parameter details.

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 the explicit verb 'Return' and names a specific resource ('satoshidata.ai on-chain Pulse scanner') with clear scope ('health and 24-hour event totals'). This differentiates it from sibling pulse_* tools that focus on specific event types.

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

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

The description implies a use case: obtaining an overall Pulse scanner health overview and 24-hour event totals. However, it does not explicitly state when to choose this over sibling tools like pulse_whales or pulse_dormant, nor does it provide 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 behavioral burden. It indicates a read-only operation via 'Return' and adds the 'live on-chain' context, but it does not mention pagination, rate limits, or whether the feed includes unconfirmed transactions, so behavioral disclosure is minimal.

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, front-loaded sentence that states the core function without any extraneous wording. It earns its place by conveying the tool's primary purpose efficiently.

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 extensive list of sibling tools, the description is too sparse to provide sufficient context for correct tool selection. It does not explain how pulse_whales differs from whale_alerts or pulse_dormant, and it omits any usage conditions, making the tool harder to use correctly in a complex environment.

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 three parameters. It hints at 'recent' (since) and 'large' (min_btc) but does not explain limit, the format of 'since', or units for 'min_btc', leaving the agent with incomplete 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 uses the verb 'Return' with the resource 'recent large Bitcoin movements' and mentions the specific source 'satoshidata.ai's live on-chain Pulse feed', clearly indicating what the tool does. However, it does not compare itself to highly similar siblings like whale_alerts or pulse_dormant, so it loses the full sibling-distinguishing 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?

The description provides no explicit guidance on when to choose this tool over the many sibling pulse/whale tools. There is no mention of exclusions, alternative tools, or use-case conditions, leaving the agent to infer applicability 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool is free and returns evidence + confidence but not a recommendation, yet it omits other behavioral aspects like data sources, update frequency, limitations, or whether any side effects occur. The phrase 'you decide whether to transact' adds interpretive context, but the disclosure is minimal.

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 entire description is a single, dense sentence that packs purpose, cost, scope, and a disclaimer without unnecessary words. It is front-loaded with the main action and reads efficiently.

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 (one parameter) and has an output schema, so return values are covered elsewhere. However, with no annotations and no mention of sibling tools or ecosystem positioning, the description leaves the agent to infer where this fits relative to address_risk, risk_check_batch, and other screening 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 coverage is 0% and the description only mentions 'one address' without adding format, validation, or example. The parameter 'address' is self-explanatory from its name, but the description does not compensate for the lack of documented details beyond what the schema already provides.

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 what the tool does with a specific verb ('return') and identifies the resource: a free evidence + confidence BTC screening bundle for a single address. It also explicitly distinguishes itself as 'not a recommendation' and implicitly separates from batch tools like risk_check_batch.

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

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

The description implies a use case (quick free screening of one address before a transaction) and includes the caveat that it is not a recommendation. However, it offers no explicit when-to-use versus alternatives or exclusions, such as pointing to risk_check_batch for multiple addresses.

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 transparency burden. It discloses that the tool is free, returns evidence and confidence scores rather than advice, and leaves the transaction decision to the user. This is meaningful behavioral context beyond the schema, though it does not cover operational details like rate limits or pagination.

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, front-loaded sentence that packs in the action, resource, limit, and a key disclaimer. Every part earns its place; there is no redundant or vague language.

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 tool with an output schema, the description is largely complete: it specifies the input limit, the nature of the output, and the non-recommendation boundary. It could be improved by explicitly naming sibling alternatives to reduce ambiguity, but given the simple interface, it is 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 input schema already describes 'addresses' as 'Bitcoin addresses to screen, in result order' with 100% coverage. The description adds the constraint 'up to 100 addresses,' which is not in the schema description. This supplemental limitation helps the agent validate input size before invoking.

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 the verb 'Return' and specifies the resource as 'free evidence + confidence BTC screening bundles for up to 100 addresses.' It clearly distinguishes from recommendation tools by stating 'not recommendations; you decide whether to transact.' This makes the purpose immediately clear, even without comparing to sibling names.

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 screening up to 100 Bitcoin addresses, but does not explicitly state when to prefer this over siblings like risk_check or batch_risk_signals. There is no 'when-not-to-use' guidance or explicit alternative naming. Usage is implied from the batch size and 'not recommendations' stance.

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 of behavioral disclosure. It mentions 'machine-readable' but does not explain what happens after submission, whether it's a write operation with side effects, permissions required, or rate limits. For a submission tool, this is a significant transparency gap.

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 sentence that starts with the verb 'Submit' and immediately conveys the tool's scope. Every word contributes meaning; there is no fluff or redundancy. This is exemplary conciseness.

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 14 parameters and no annotation coverage, the description is far too sparse. It fails to explain required parameters, valid feedback_type values, or how to structure the submission. While an output schema exists, it does not compensate for the lack of input guidance. The description is only a purpose statement, not complete enough for 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 description coverage is 0%, and the description does not explain any parameter semantics. The required feedback_type parameter is never described, and the relationship between the listed feedback subtypes and the numerous optional parameters (suggested_label, current_label, reason, etc.) is unstated. Parameter names provide some hints, but the description adds no meaningful guidance.

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 submits feedback, listing four specific subtypes (label corrections, missing-label suggestions, data-quality reports, general feedback). This distinguishes it from the many data-query sibling tools. The verb 'Submit' and resource 'feedback' are specific and 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 provides clear context for when to use the tool: when submitting machine-readable feedback of the listed types. It implies these scenarios are distinct from querying data, though it doesn't explicitly name alternatives or state when not to use. This meets the 'clear context, no exclusions' level.

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 must disclose behavioral traits. It indicates a write operation ('submit') and the target system, but does not describe side effects, idempotency, rate limits, or prerequisites. It conveys the basic nature of the operation but lacks depth for a mutation 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?

The description is a single, focused sentence with no filler. It front-loads the action and resource, making it immediately clear what the tool does. Every word 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 tool is simple (one parameter, output schema present) and the description covers the core action. However, it lacks context about the workflow—e.g., whether a prior quote is needed via sibling tools like timestamp_quote, or what happens after submission (confirmation, async processing). With no annotations, this gap reduces completeness.

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 meaning by specifying that the hash is a 'SHA-256 digest', which clarifies the expected content for the `hash_hex` parameter. However, it doesn't detail format constraints (e.g., 64 hex characters) or encoding, leaving some ambiguity. The schema itself only provides a title, so the description provides partial value.

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 action: 'Submit a SHA-256 digest' to a specific destination ('satoshidata.ai's Bitcoin timestamping batch'). It uses a specific verb ('submit') and resource ('SHA-256 digest'), and distinguishes itself from sibling tools like timestamp_quote or verify_timestamp by focusing on the submission step.

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 for when to use the tool: when you want to submit a SHA-256 hash for Bitcoin timestamping. It does not explicitly mention alternatives or exclusions, but the action is unambiguous. Since it doesn't say 'use this instead of X' or mention prerequisites, it falls 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 burden. It accurately describes what the tool returns (fee and anchor-fee share), but does not disclose whether the quote is guaranteed, whether any side effects exist, or if there are rate limits. The 'preflight' wording hints it is a non-mutating quote, but this is not explicitly stated.

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, front-loaded sentence that conveys all essential information without unnecessary words. It is perfectly sized for a tool with no parameters.

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 (0 params) and the presence of an output schema, the description is sufficiently complete. It states the core purpose and contents of the quote. However, it does not mention how this fits into the broader timestamping workflow (e.g., that it should be called before timestamp_hash), so it is not fully contextually rich.

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 properties object, so there is no schema to clarify. The baseline for 0 params is 4, and the description correctly focuses on the tool's output rather than dwelling on non-existent 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 uses a specific verb 'Return' and clearly identifies the resource as 'current Bitcoin timestamping preflight quote'. It also specifies the contents (fixed service fee and estimated anchor-fee share), which distinguishes it from sibling tools like timestamp_hash and verify_timestamp.

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 this tool is used before performing a Bitcoin timestamping operation ('preflight quote'), but it does not explicitly state when to use it versus alternatives or mention any exclusions. No alternative tools are named, so guidance is only implied.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It fails to mention that broadcasting is an irreversible network write operation, potential side effects (such as the transaction being propagated and mined), authentication requirements, error conditions (e.g., invalid signature, already spent inputs), or any rate limits. The description is a bare action statement with no 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 a single concise sentence that front-loads the verb 'Broadcast' and delivers the core purpose without redundancy. Every word earns its place, and the structure is clear and appropriately sized for a simple 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 that this is a write/broadcast operation with no annotations, the description is incomplete. It does not disclose the irreversible nature of broadcasting, potential side effects on the Bitcoin network, authentication needs, or mention related tools like tx_status or tx_verify for verification. The simplicity of the tool is mitigated by the fact that the output schema exists, but safety and side-effect context are entirely 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's 'hex' parameter has no description, and schema coverage is 0%. The description adds key semantic meaning by specifying that the hex must be a 'fully signed raw Bitcoin transaction hex', clarifying the expected format and domain of the value beyond 'string'. This is essential for correct usage, although it does not explain the exact encoding or provide examples.

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 (broadcast), the object (fully signed raw Bitcoin transaction hex), and the channel (through satoshidata.ai). It distinguishes from sibling tools by the unique verb 'broadcast' and the specific resource of a raw transaction hex, which none of the sibling tools (mostly query/intelligence tools) perform.

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 no explicit guidance on when to use this tool versus alternatives, no prerequisites, and no exclusion criteria. While the purpose is clear, the description does not mention that the transaction must be fully signed and ready for network propagation, nor does it direct users to related tools like tx_status or tx_verify for post-broadcast monitoring.

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 burden of behavioral disclosure. It indicates a read-only operation by using 'Return', and it discloses the output states. However, it does not mention error behavior (e.g., invalid txid), network requirements, or whether the check is local or remote, leaving some behavioral aspects 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?

The description is a single, focused sentence that front-loads the purpose and lists all output states. It contains no unnecessary words or repetition, making it concise 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 the tool's simplicity (one parameter, simple state check) and the presence of an output schema (which presumably defines the return states), the description is largely complete. It communicates the essential behavior and output options, though it could benefit from a brief note on error handling or relation to sibling 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?

The input schema has one parameter (txid) with 0% description coverage, and the tool description does not directly explain the parameter format or semantics beyond the tool's own name and the phrase 'Bitcoin transaction'. This provides minimal compensation for the lack of schema description, but it does not explicitly clarify that txid is the transaction ID or its expected format.

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: 'Return a narrow Bitcoin transaction state check' with explicit possible states (unknown, mempool, conflicted, confirmed). The verb 'Return' and resource 'Bitcoin transaction state check' are specific, and the word 'narrow' distinguishes it from more comprehensive transaction tools like mempool_tx or tx_verify.

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

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

The description implies a lightweight, narrow usage via the word 'narrow', and the enumerated states clarify what to expect. However, it does not explicitly state when to use this tool versus alternatives (e.g., when full transaction details are needed, use mempool_tx), nor does it mention any exclusions or prerequisites.

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 must disclose behavioral traits on its own. It explains the core checks (amount, address, confirmations) but does not describe edge cases like what happens if the transaction is not found, or whether 'paid enough' includes fees. It remains somewhat opaque about internal 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?

A single, front-loaded sentence with no wasted words. It captures the essential purpose and parameters efficiently.

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 output schema exists, the return value is already defined. The description covers the main functionality and parameter semantics, but could include more context on error handling or exact verification logic. Still, it is sufficient for most use cases.

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 descriptions, so the description compensates by mapping 'paid enough sats' to min_amount_sats, 'to the expected address' to expected_address, and 'enough confirmations' to min_confirmations. This adds meaning beyond the bare parameter names, though it does not detail each parameter individually.

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 verb (verify) and resource (Bitcoin transaction) with precise conditions (paid enough sats to expected address with enough confirmations). This distinguishes it from siblings like tx_status, which likely just checks status, and address_intelligence, which focuses on addresses.

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: use when you need to confirm payment conditions. However, it does not explicitly mention when not to use it or name alternative tools, though the specificity makes the use case clear.

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 must communicate behavioral traits. It only states that it 'verifies', without disclosing side effects (e.g., read-only), error handling, or prerequisites. This is a significant gap for a verification 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?

A single, clear sentence with no redundant words. The description is efficient and 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 simple one-parameter tool with an output schema, the description covers the core purpose but lacks usage guidance and behavioral details. It is minimally adequate but leaves out important context like what happens when a proof is invalid.

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 mentions 'detached OpenTimestamps proof', which gives context to the proof_base64 parameter, but it does not elaborate on format requirements or constraints beyond what the param name implies. Partial compensation only.

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 specific action: verifying a detached OpenTimestamps proof against the Bitcoin blockchain. This distinguishes it from sibling tools like timestamp_hash and timestamp_quote, which involve different steps in the timestamping process.

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 when you have a detached OpenTimestamps proof to verify, but it does not explicitly mention when to use this tool versus alternatives like timestamp_hash or tx_verify. It lacks explicit exclusions or alternative tool references.

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. It implies a read-only operation via 'Return' and describes the output types, but it does not disclose potential rate limits, data freshness, or whether any API key is required. This is adequate for a simple lookup but minimal.

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 sentence, front-loaded with the verb, no filler. It efficiently communicates the tool's purpose and input scope without unnecessary detail.

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 (single param) and the existence of an output schema, the description covers the essential invocation context. It does not explain the meaning of 'contributor depth' or 'category distribution', but the output schema likely handles that. Missing usage guidance slightly reduces completeness, but the core functionality is clear.

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 only defines 'address' as a string with no description. The tool description adds meaning by specifying it is a 'single Bitcoin address', clarifying the parameter's type (Bitcoin) and cardinality (single vs. batch), which helps disambiguate from batch-oriented siblings.

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 specifies a clear verb ('Return'), a distinct resource ('satoshidata.ai contributor depth and category distribution'), and a clear scope ('single Bitcoin address'). It differentiates from sibling tools like wallet_summary and address_intelligence by naming a specific metric not implied by others.

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 no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or context in which this tool is preferred over sibling tools like wallet_flow_graph or address_evidence_pack.

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 of behavioral disclosure. It only states 'Return' (implying read-only) and 'grouped label evidence,' but does not disclose permissions, rate limits, or any side effects. With no annotations, this is insufficient.

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 sentence that is front-loaded with 'Return' and contains no filler. Every word contributes meaning, making it appropriately concise 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?

An output schema exists, so return-value details are covered. For a one-parameter lookup tool, the description conveys the core scope adequately, though it lacks usage alternatives and deeper behavioral context.

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

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

The schema has one required 'address' parameter with no description (0% coverage). The description clarifies it is a 'single Bitcoin address,' which adds minimal semantic context beyond the schema's type/title and is enough to understand the parameter'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 uses 'Return grouped satoshidata.ai label evidence and detail for a single Bitcoin address,' which clearly identifies the verb, resource, and scope. It distinguishes itself from siblings by emphasizing 'grouped label evidence' and 'single address.'

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 provided on when to use wallet_detail versus alternatives like address_evidence_pack or wallet_summary. The description does not mention exclusions, prerequisites, or alternative 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?

Annotations are absent, so the description must disclose behavioral traits. It only states the output is 'render-ready,' implying format readiness but not addressing read-only status, rate limits, or potential side effects. The description does not explain how parameter interactions affect the graph (e.g., min_btc as a filter), leaving behavioral ambiguity.

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 with no wasted words. It is front-loaded with the core action and resource, making it appropriately sized and easy to scan.

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 is sufficient only for a basic understanding of the tool's purpose. It lacks usage context, alternative comparisons, and behavioral details that would be necessary for an agent to fully leverage this tool, despite the rich schema and 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?

Schema description coverage is 100%, so each parameter is already described. The description adds no extra semantic meaning beyond the schema; the only hint is 'render-ready,' which relates to output, not 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 clearly identifies the tool's function: 'Return a render-ready transaction-flow graph for a Bitcoin wallet address.' The verb 'Return' and resource 'transaction-flow graph' are specific, but it does not explicitly distinguish from sibling tools like wallet_summary or address_evidence_pack, 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?

No guidance is provided on when to use this tool versus alternatives. The description lacks any mention of use cases, prerequisites, or exclusions, leaving the agent without direction on selecting this over other wallet/address 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?

No annotations are provided, so the description must carry the full burden of disclosing behavior. It only says 'Return', which weakly implies a read-only operation, but it does not disclose potential access requirements (premium), error behavior, or any other operational traits. This is minimal 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 description is a single sentence with no filler. It is front-loaded and every word contributes to conveying the core purpose, making it appropriately concise.

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 an output schema exists, the description lacks key contextual information. It does not differentiate from closely related sibling tools, does not explain the 'premium' aspect, and offers no usage context. For a tool with one parameter and available sibling alternatives, this is insufficient.

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 one required parameter 'address' with zero description coverage. The description adds essential context by clarifying it is a Bitcoin address, which the schema lacks. However, it does not specify expected format (e.g., base58, bech32) or how it relates to the returned summary, so it only partially compensates for the 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 it returns a chain intelligence summary for a single Bitcoin address, using the specific verb 'Return' and the resource 'chain intelligence summary'. It does not explicitly differentiate from sibling tools like address_intelligence or wallet_detail, so it doesn't fully 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 description provides no guidance on when to use this tool versus alternatives. It does not mention suitable scenarios, exclusions, or when another tool might be preferred, leaving the agent without clear selection criteria.

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 responsibility for behavioral disclosure. It does add value by mentioning the 'examined marker when no clear category matched' and labeling the output as a 'free teaser,' which hints at limitations. However, it does not address authorization, rate limits, or what the teaser includes/excludes beyond the marker behavior, leaving notable gaps given the lack of annotations.

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

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

The description is a single sentence that is front-loaded with the action and target. Each clause adds meaningful information: the purpose, the single-address scope, and the marker behavior. There is no redundant or filler language, making it highly concise 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?

The tool is relatively simple with one parameter and an output schema, so return value details are likely covered elsewhere. However, the description does not define what a 'teaser' entails or how this tool fits among sibling wallet/risk tools, leaving the agent reliant on guesswork. The marker behavior is a positive addition, but the overall context remains incomplete.

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 a single 'address' parameter with no description, and the tool description provides no additional semantic detail about address format, validation, or network. Though the description references 'a single address,' it does not clarify how the parameter should be supplied or what constraints exist, so it fails to compensate for the 0% schema 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 specifies a clear action ('Return') and resource ('wallet trust and safety teaser for a single address'), giving the tool a defined purpose. It distinguishes from batch operations by explicitly stating 'single address,' but the term 'teaser' is somewhat underspecified and it does not directly name alternative tools, so it falls short of full sibling 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 phrase 'for a single address' implies the use case, but the description offers no explicit guidance on when to use this tool versus alternatives such as batch_trust_safety, risk_check, or wallet_detail. No exclusions or alternative tool names are mentioned, leaving the choice to the agent without support.

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?

Without annotations, the description must convey behavioral traits itself. It does add useful details like the 24h alias and classification outcomes (to_exchange, from_exchange, cross_exchange, unknown). However, it does not disclose any side effects, pagination behavior, or rate limits. Since this is a read-only operation, the lack of risk disclosure is less critical, but transparency remains limited.

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 long, front-loaded with the core purpose, and every sentence adds value. It avoids unnecessary repetition of schema information and is well-structured for quick comprehension.

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 that an output schema exists and the parameters are fully documented, the description covers the essential context: what the tool does, key filtering options, and classification behavior. It could mention sorting order or pagination, but those are already hinted at in the schema's offset description, so the description 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?

The input schema already provides 100% coverage with descriptions for all five parameters. The description adds some context about range values and classification, but these are mostly redundant with schema descriptions. Since the baseline for full schema coverage is 3, this score is appropriate.

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

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

The description clearly states the tool's function: returning recent large Bitcoin transfers with specific flow classification. It mentions label-DB flow_type and flow_direction, which are distinctive attributes that help differentiate this tool from sibling tools like pulse_whales or chain_awakenings.

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 operational context by specifying valid range values and the legacy alias behavior for 24h. However, it does not explicitly state when to use this tool over alternatives or when not to use it, so it stops short of full usage guidance.

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