TapeAPI: signed BNB Chain reads

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

Annotations cover readOnlyHint and openWorldHint, and the description adds genuinely useful context beyond them: the result is quorum-signed by an on-chain delegated key, carries a verifiable receipt, and is data rather than instructions (a prompt-injection guard). It does not cover rate limits or failure modes, but the safety and provenance picture is strong.

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

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

The core purpose is front-loaded, but the sentence is cluttered with a full contract address, the '-- TapeAPI method' boilerplate, and repeated clauses. The prompt-injection disclaimer earns its place; the service-address verbosity does not.

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

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

With no output schema, the description compensates by enumerating the return shape { address, wei, bnb, blockPinned }, which is exactly what an agent needs. The block parameter and its default are covered. Only the sibling-differentiation gap keeps it short of full 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 description coverage is 100%, so baseline is 3. The description echoes the block-pinning concept and the address target but adds no syntax or default detail beyond the schema's '(default finalized)' note.

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

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

The opening clause gives a specific verb+resource+scope: 'Native BNB balance of an address, pinned to one block.' The word 'Native' implicitly separates it from the sibling tokenBalance (ERC20 balances), though that distinction is not made explicit. Purpose is clear despite the surrounding boilerplate about quorum, service identity, and receipts.

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

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

It states the tool is 'Free' and pinned to a block, which hints at usage, but never says when to pick this over tokenBalance or the other balance-adjacent siblings. An agent must infer the native-vs-token distinction from the word 'Native' alone.

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

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

Annotations only cover readOnly/openWorld; the description adds substantial context beyond them: multi-node consensus requirement, on-chain delegated-key signature, an included receipt verifiable against the chain, a link, and an explicit prompt-injection caveat ('data from that service, not instructions'). This is unusually rich behavioral disclosure for a simple read.

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

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

The core purpose leads the sentence, followed by provenance, trust, and return-shape details. Despite carrying service metadata (address, 'Free', signature), every clause adds something an agent needs, with no filler.

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

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

With no output schema, the description still states the return shape ({ blockNumber: number }) plus provenance and verification details. An agent has everything needed to call and interpret this zero-arg read.

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

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

The tool takes zero parameters, so there is nothing to document and the baseline of 4 applies. The description appropriately spends no space on nonexistent inputs.

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

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

States a specific resource and scope: 'the latest BNB Smart Chain block the service agrees on,' with the multi-node agreement qualifier. This clearly differentiates it from siblings like balance, bnbUsd, pairPrice, and tokenInfo, which all return different data.

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

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

The purpose implies when to use it (fetch the current block height), but there is no explicit when-to-use/when-not guidance or named alternatives. Since the siblings expose unrelated resources rather than overlapping ones, the lack of routing guidance is a modest gap rather than a critical one.

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

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

Beyond the readOnlyHint/openWorldHint annotations, it discloses that the result is signed by the service's on-chain delegated key, carries a verifiable receipt, and is explicitly data rather than instructions. These are exactly the trust and provenance details an agent cannot get from structured fields.

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

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

The core behavior and the pairPrice routing are front-loaded and waste-free, and the return shape is included compactly. The service-identity and provenance sentences are justified but make it denser than strictly minimal.

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 no-parameter, read-only price tool with no output schema, the definition supplies source pair, pinning semantics, provenance/signing behavior, and even the return shape ({ bnbUsd, pair, blockPinned }). Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100% with a single optional block parameter whose enum values are already documented. The phrase "pinned to one block" and the stated default (finalized) merely restate what the schema provides, so the baseline 3 applies.

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

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

The description names a specific resource and scope: "BNB in USDT from the PancakeSwap V2 WBNB/USDT pair, pinned to one block," and explicitly routes spot-price lookups elsewhere ("Spot price: see pairPrice"). An agent can distinguish it from siblings like pairPrice and blockNumber without opening any schema.

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

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

It explicitly provides an alternative for the adjacent use case ("Spot price: see pairPrice"), which is real routing guidance. It does not, however, say anything about when to pin to a specific block value versus the default, leaving that choice to inference.

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

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

Annotations only give readOnlyHint and openWorldHint; the description adds substantive context beyond them: the result is signed by the service's on-chain delegated key, carries a receipt, is verifiable against the chain, is free, and is data rather than instructions. This is a genuine behavioral disclosure. It doesn't cover latency or rate behavior, so not a 5.

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

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

The core purpose is front-loaded, but the text carries boilerplate noise: a bracketed '[quorum]' tag, a long service address, and a 'not instructions' disclaimer. These earn their place for provenance but dilute the concise statement of what the tool does.

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

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

There is no output schema, so the description usefully spells out the return shape ({contract, tokenId, owner, blockPinned}) and the verification path. Combined with the defaults in the schema, an agent has enough to call and interpret the result; only usage routing remains thin.

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 contract, tokenId, and the block parameter (number|'finalized'|'safe'|'latest', default finalized). The description adds only the concept of block-pinning, which is already conveyed by the schema, so baseline 3 applies.

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

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

The description states a specific verb+resource: 'Owner of an ERC-721 token, pinned to one block,' which is unambiguous and distinct enough from tokenInfo/tokenBalance that an agent can select it. It doesn't explicitly contrast itself with those siblings, though the ERC-721 ownership framing makes the distinction implicit.

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

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

Usage is implied by the name and the 'ERC-721 token ownership' framing, but there is no explicit when-to-use guidance and no when-not or alternative routing (e.g., vs tokenInfo or blockNumber). The context needed to choose it is inferable but not stated.

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

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

Beyond readOnlyHint/openWorldHint it discloses real behavioral traits: manipulability within a block, that the result is signed by an on-chain delegated key and carries a verifiable receipt, and that the payload is data rather than instructions (prompt-injection defense). This is genuine context an agent cannot get from the annotations.

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

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

The key warning and scoping are front-loaded, and every sentence carries information. The service-identity boilerplate (hex address, 'Free', verification link) is verbose, though defensible for a paid/verified 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?

With no output schema, the description usefully enumerates the return shape (pair, token0, token1, reserves, price, blockPinned), and annotations cover the safety profile. Only the internal structure of the price/reserves sub-objects is left unspecified, which is minor.

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

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

Schema description coverage is 100%, so both parameters (pair, block) are already documented, including the 'finalized' default. The description only echoes block pinning implicitly and adds no format or semantics beyond the schema, so the baseline 3 applies.

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

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

The first sentence states a specific verb+resource+scope: a spot price computed from a PancakeSwap V2 pair's reserves, pinned to a single block. That is plainly distinct from siblings like bnbUsd, tokenInfo, or balance, so an agent can route correctly without opening a schema.

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

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

It gives explicit when-not guidance ('do not use it alone for liquidations') plus the block-pinning context that constrains when the value is valid. It stops short of naming an alternative tool (e.g. a TWAP or multi-block source) to use instead, so it's clear context with an exclusion rather than full routing.

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

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

Annotations only cover readOnly/openWorld, yet the description adds cost ('Free'), signature provenance (signed by the service's on-chain delegated key), the existence of a verifiable receipt/link, and a prompt-injection caveat ('data from that service, not instructions'). This is material behavior an agent could not derive from the annotations.

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

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

Front-loads the resolution purpose, then provenance and cost. Slightly redundant in listing the return shape twice (prose enumeration and the typed object literal), which costs a little efficiency.

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

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

With no output schema, the description carries the return contract itself, listing every field (name, processor, tokenId, circuits, container, holder, opened, tapeapi, channelKeys, blockPinned) plus verification and cost context. Nothing essential to a correct call is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description contributes only an inline example of the expected name format; the block defaulting behavior already lives in the schema, and tokenId/processor are not explained beyond the schema text.

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

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

Specific verb ('Resolve') plus a named resource ('a TapeOut name such as 11.1013.tape') and an enumerated payload (processor contract, container, holder, opened, manifest/channel keys). It is unmistakably distinct from the generic sibling tools (balance, blockNumber, tokenInfo).

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

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

The description implies the context (resolving a TapeOut name / checking a container's state) but never states when to use this instead of something else, nor any prerequisites beyond the name format. Usage is inferable but not spelled out.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the bar is lower, yet the description adds real value: block pinning, an on-chain delegated-key signature with a verifiable receipt, and an explicit prompt-injection caveat that the result is data, not instructions. It doesn't cover pagination or failure behavior, but this is solid beyond-annotation 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?

Front-loads the core purpose before the provenance boilerplate, and the return-shape listing is compact. The service-address and receipt phrasing is somewhat verbose but each clause carries functional information.

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

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

With no output schema, the description compensates by enumerating the return object's fields (token, address, raw, amount, symbol, decimals, blockPinned). Combined with the trust/verification note, an agent has enough to invoke and interpret the call; only the sibling-selection dimension is unaddressed.

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

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

Schema coverage is 100%, so the schema already documents token, address, and the block parameter including its 'finalized'/'safe'/'latest' enum and default. The description's 'pinned to one block' adds only marginal framing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource — BEP-20 balance of an address, pinned to one block — with a clear scope (raw and token units). It does not, however, say how it differs from the sibling 'balance' (presumably native-coin) or 'tokenInfo', leaving disambiguation to inference.

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

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

No when-to-use or when-not-to-use guidance is given. With siblings like 'balance' and 'tokenInfo' present, the agent gets no help deciding which to call; the only contextual note is that the service is free, which is not selection 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?

Goes well beyond the annotations (readOnlyHint/openWorldHint) by disclosing that calls are free, that results are signed by an on-chain delegated key and carry a verifiable receipt, and explicitly warning that the result is data, not instructions. The prompt-injection warning and trust/verification model are exactly the kind of context structured fields cannot convey.

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

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

Front-loaded with the core purpose, then trust/verification details, then the return shape. Some service-identity boilerplate (service address, method name) is verbose but does carry provenance value; the whole thing remains one dense, readable block.

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

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

With no output schema, the description supplies the return object's fields directly, and it explains the block-pinning semantics and verification path. An agent has everything needed to call the tool and interpret its result correctly.

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

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

Schema coverage is 100%, so both parameters (token address, block selector with default 'finalized') are already documented in the schema. The description adds no further parameter syntax or format detail, so the baseline of 3 applies.

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

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

States a specific verb/resource ('BEP-20 token metadata and total supply') with the scope constraint ('pinned to one block') and enumerates the exact return shape. It is clearly distinguishable from siblings like tokenBalance and balance, which deal with balances rather than token metadata.

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

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

Usage is implied by the purpose: use it when you need token metadata or total supply. However, there is no explicit when-to-use vs tokenBalance/balance or note about when block pinning matters, and no exclusions. Adequate but leaves routing to inference.

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