bobai

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

Annotations already establish readOnlyHint=true and destructiveHint=false. The description goes beyond this by disclosing methodology: 'Every id read, nothing extrapolated' and highlighting that some registrations may not even be readable. This adds honesty about scope and limitations without contradicting 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 description is a single, information-dense sentence that front-loads the core purpose. The enumerated metrics are each meaningful, and the closing methodological note earns its place. It is slightly stylized but not padded.

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

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

For a read-only, zero-parameter statistical tool, the description is sufficiently complete: it names the chain, the registry standard, the specific metrics, and the scope of the read. Without an output schema, it could theoretically describe the return shape more explicitly, but the listed counts give a strong expectation of what will be returned.

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 zero parameters and 100% schema description coverage, there is no parameter burden for the description to carry. Baseline 4 applies because no additional parameter-level meaning 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 identifies the tool as a registry census for ERC-8004 on BNB Smart Chain and enumerates the specific metrics it reports. This distinguishes it from sibling tools like find_agents_on_bnb_chain, which focus on locating agents rather than aggregating registry-level statistics.

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

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

The description makes the context unmistakable: this is the aggregate overview tool for the agent registry, listing counts such as registered agents, readable registrations, endpoint availability, responsiveness, and operators. It does not explicitly name alternatives or when-not-to-use, but the census framing is clear enough for an agent to select it appropriately.

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

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

Annotations already declare this a safe read (readOnlyHint=true, destructiveHint=false), so the bar is lower, and the description clears it by disclosing data provenance and a real caveat: metrics are 'measured rather than self-reported', own test purchases 'never count as outside buyers', and uptime/response come from a 'daily pulse'. It stops short of stating freshness, caching, or behaviour for an unknown agent_id.

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

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

Front-loaded identity ('Brain Plaza agent chart — one AI agent on BNB Smart Chain'), then one tightly packed colon-list of measured fields, then a one-line directive. Dense but every clause carries distinct content; 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?

There is no output schema, so the description must carry the return-value burden and it does: it enumerates the metric groups and the 0-100 evidence score. Combined with read-only annotations and a fully documented single parameter, an agent has what it needs, though the shape of the evidence-score breakdown is only gestured at.

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 single agent_id parameter already documented as an ERC-8004 id with an example (302257). The description only reinforces that the chart covers 'one AI agent', adding no format or lookup 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 description states a specific resource (a single agent's measured profile on BNB Smart Chain) and enumerates exactly what the chart contains: uptime, response time, escrow-paid jobs, delivery rate, pricing behaviour, ERC-8004 ratings and an evidence score. That makes it distinguishable from aggregate siblings like bnb_agent_census or bnb_agents_by_evidence by implication, though no sibling is named explicitly.

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

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

The closing line 'Use it before hiring an agent' gives a clear usage context, but there is no when-not guidance and none of the eight agent-related siblings (bnb_agent_census, bnb_agents_by_evidence, bnb_agent_employment, find_agents_on_bnb_chain) are referenced as alternatives. Usage is implied rather than routed.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds real value beyond them: this is a dated snapshot rather than a live call, and measured_at carries the freshness timestamp — an agent that needs live data would otherwise be misled.

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 question, then scope, then the parameter behavior, then the staleness caveat. Every sentence carries distinct information; nothing is redundant padding.

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 what gets counted (jobs created, funded, deliverables submitted, escrow released) and flagging the snapshot/measured_at caveat. It is nearly complete; the only gap is any hint at the shape or granularity of the returned per-provider record.

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% and the sole parameter is already documented as an optional provider address with omit-for-summary semantics. The description restates that same behavior ('pass an address ... or nothing for the whole kernel') without adding format, validation, or edge-case detail, 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?

Names the exact resource (ERC-8183 job escrow kernel on BNB Smart Chain) and the specific signal it returns (hired and paid providers), which cleanly separates it from self-reported registration data and from siblings like bnb_agent_census or find_agents_on_bnb_chain.

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

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

Gives concrete call conditions: pass an address for one provider's balance, omit it for the whole kernel. It also contrasts 'a registration is self-reported' against 'a funded job is somebody else's money', implicitly telling the agent when this tool beats a census tool, though it never names the sibling outright.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description goes beyond that by disclosing the ranking inputs (30-day uptime, escrow delivery rate, paying outside buyers, price disclosure) and the important behavioral guarantee that paid listings never affect order — a genuinely useful trait not present in 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?

It is front-loaded with the core purpose and the anti-payola guarantee comes last where it lands well. The metric enumeration is slightly dense marketing prose, but every clause conveys ranking semantics rather than 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 only two parameters, full schema coverage, annotations covering safety, and no output schema to explain, the description supplies what an agent needs: what is listed, how it is ordered, and the categories accepted. Only the absence of sibling routing keeps it short of complete.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema. The description restates the four valid categories but adds no formatting or semantic detail beyond the enum list, and never addresses the limit parameter. 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 states a specific resource (AI agents on BNB Smart Chain) and the organizing principle (ordered by evidence), so an agent can tell this is a ranked discovery/list tool. It does not, however, distinguish itself from the sibling find_agents_on_bnb_chain, which looks like a near-neighbor.

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

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

Usage is implied rather than stated: pick a category and receive agents ranked for 'one job'. There is no explicit when-to-use / when-not-to-use guidance and no routing to or away from find_agents_on_bnb_chain or bnb_agent_census, which is a real gap for a discovery tool with close 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds real behavioral context beyond the annotations: the data provenance (public audit log, every entry verifiable on-chain) and the shape of what is returned. It stops short of describing pagination or freshness/refresh cadence, so it is strong but not exhaustive.

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 returned payload, then the usage/routing sentence. Slightly inflated by framing language ('flywheel is actually running', 'Proof the...'), which costs a little efficiency but does not obscure the actionable 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?

With no output schema, the description carries the burden of describing returns and does so concretely (last burn + tx, 7/30-day burn counts, total bot runs) along with provenance. An agent has everything needed to call and interpret this read-only 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 tool takes zero parameters, so the description correctly spends no space on parameter semantics and there is nothing in the schema to compensate for. Baseline 4 for a no-param tool.

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

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

States a specific resource (activity / audit log) and enumerates exactly what it returns: last burn with BscScan tx, burns over 7/30 days, and total bot runs. It explicitly distinguishes itself from siblings bobai_smart_money and bobai_burned, so an agent can select it without opening other schemas.

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

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

Gives an explicit when-to-use ('verify that burns really happen and how often') and routes two adjacent intents to named alternatives: bobai_smart_money for next buyback/whale flows and bobai_burned for the burned total. Nothing is left to inference.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds real context beyond that: the burn is done by an autonomous 24/7 buyback-and-burn bot to the zero/dead address, which tells the agent the number is live and machine-driven rather than a static constant.

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 compact clauses: the definition of the metric first, then the routing rule. No filler, and the most important information (what is counted) 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 zero-parameter, no-output-schema tool this covers what the value is, how it is produced, and when to prefer it over a richer sibling. It stops short of stating units or a refresh cadence, which is a minor gap.

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 for the description to disambiguate; the baseline for a parameterless tool applies. The description correctly implies no inputs are needed to fetch the total.

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 ('Total $BOBAI permanently burned') and clarifies the mechanism (sent to the dead/zero address by the buyback-and-burn bot). It also explicitly contrasts itself with the sibling bobai_token_info, so an agent can distinguish it without opening schemas.

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

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

Gives an explicit selection rule ('Use it when only the burned total is needed') and names the alternative ('bobai_token_info returns it with the other supply figures'). The when-to-use and when-not-to-use conditions are both stated.

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

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

Annotations already establish the safety profile (readOnlyHint=true, destructiveHint=false), so the description only needs to add context. It does: it defines the derivation of the value (total minus burned) and clarifies the narrow output shape. It stops short of stating freshness/caching or numeric precision, which would be the remaining useful detail for a live supply metric.

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, both front-loaded with the highest-value information: first what the number is, then when to pick it over the sibling. No filler or restated title.

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

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

For a zero-parameter, read-only scalar lookup with no output schema, the description supplies everything needed: what the value means, how it is derived, and when to prefer it over bobai_token_info.

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

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

The tool takes zero parameters, which is the baseline-4 case. The description correctly implies argument-free invocation and spends its words on the returned figure instead of inventing parameter semantics.

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

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

States a specific resource and metric ($BOBAI circulating supply) and immediately defines it operationally as total supply minus burned tokens. It also names the sibling bobai_token_info, so the agent can distinguish the two without opening either 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?

Explicitly says when to use it ('when only this one figure is needed, e.g. a market-cap check') and names the alternative (bobai_token_info) with the condition that selects it. Nothing is left to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds real context beyond that: the values are read live from the chain, they are the fee-on-transfer parameters a naive swap would fail without, and it gives concrete measured numbers (3% tax, ~6% slippage for a ~$100 trade). It does not discuss caching/freshness or chain selection, keeping it below 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?

Front-loaded with the core purpose and the returned values, and the closing sentences carry the routing guidance. However, the second sentence is a long, densely nested construction with stacked parentheticals (the 3%/6%/$100 figures inside a clause about the settings) that is harder to parse than it needs to be.

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

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

With no output schema, the description carries the burden of explaining return values and does so by enumerating every field the agent will receive, plus what to do with them. What is missing is freshness/staleness behavior and the target chain, but for a zero-parameter read tool this is nearly complete.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4. The description correctly implies a no-argument, read-everything-necessary call.

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?

Names a specific resource (the DEX parameters for a $BOBAI trade) and enumerates exactly what is returned: PancakeSwap V2 router, pair, both swap paths, fee-on-transfer tax and slippage, and the SupportingFeeOnTransferTokens method names. It is clearly distinguishable from siblings like bobai_token_info, bobai_price, and bobai_purchase_guide.

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

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

Explicitly states the use condition ('Use it before writing your own swap code') and names the alternative with the condition that selects it ('for ready-made code use bobai_purchase_guide'). It also warns that a naive swap reverts without these numbers, which is a concrete reason to call it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds real behavioral content: it is an interactive guide exposing 'what you can ask', 'what you can do', tool selection, and a fee-on-transfer rule. It does not describe return formatting, but for a zero-parameter guide tool this is minor.

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

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

Front-loaded with the key scoping fact ('Start here for $BOBAI itself') and the alternative is parenthesized early. The final sentence ('Call it first when you are unsure...') restates the routing already implied, so it is slightly redundant but still short and 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?

For a zero-param, no-output-schema orientation tool, the description covers purpose, scope, alternative routing, and what the guide surfaces. Nothing essential for calling it correctly is missing; only return-shape detail is absent, which is acceptable here.

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 no parameters, so there is nothing to document and the baseline is 4. The description correctly implies a stateless, argument-free call.

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 ($BOBAI) and function (interactive orientation guide that tells you what to ask and which tool to call). It explicitly scopes itself against the sibling bsc_token_preflight for other tokens, so an agent can distinguish it 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?

Gives an explicit when-to-use ('Call it first when you are unsure which $BOBAI tool fits') and an explicit when-not/alternative (any other token → bsc_token_preflight). Routing conditions are fully stated, leaving nothing to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful context by framing this as a link-directory return rather than raw data and enumerating the link set, though it says nothing about auth, freshness, or format beyond 'live burn audit log'.

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

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

Two tight sentences: the first front-loads the resource and its contents, the second handles routing. No filler and nothing redundant with structured fields.

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 no output schema, the enumerated link list effectively describes the return value, and the when-to-use sentence covers the routing decision. 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?

The tool takes zero parameters, so there is no parameter semantics to document; the baseline of 4 applies. The description correctly implies a self-contained, argument-free retrieval.

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 (official $BOBAI links) and enumerates exactly what is returned (website, BscScan verified source, X, Telegram, DexScreener, GeckoTerminal, CoinGecko, live burn audit log, llms.txt). It also distinguishes itself from the many bobai_* data siblings by noting agents should get data from other 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?

Explicitly says when to use it ('when a person needs a link to open') and when not to ('an agent gets the data itself from the other tools'). This directly routes between this tool and the numerous data-oriented siblings without ambiguity.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond that: it is 'live', returns LP-burned percentage as 'perma-locked', and covers buy sizes of 0.1–5 BNB. It doesn't discuss caching freshness or staleness of the 'live' data, but for a zero-param read tool this is solid.

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

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

Two sentences with no waste: the first front-loads what is returned, the second immediately handles routing. Every clause 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?

No output schema exists, so the description carries the burden of explaining return values, and it does so explicitly by listing the four data points returned. With annotations covering safety and no parameters to document, nothing an agent needs to invoke 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The 0.1–5 BNB range mentioned describes output coverage, not an input, and is correctly framed as estimates it provides rather than something the caller supplies.

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 (live $BOBAI liquidity depth) and enumerates exactly what it returns: pool reserves, USD liquidity, LP-burned percentage, and price-impact estimates. It also names the sibling it is not (bobai_price for price alone, bsc_pool_scan for other BSC tokens), so an agent can distinguish it 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?

Explicitly states the use case ('size a trade') and routes to alternatives with conditions: 'for the price alone use bobai_price, for any other BSC token bsc_pool_scan.' Both the when and the when-not are covered.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered; the description goes further by disclosing the underlying mechanic (auto-mint, no claim, no signup, capped supply) and what the response contains. It does not cover refresh cadence or whether supply is chain-live vs cached, which is a minor gap for a read-only informational 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 substance is front-loaded (what the reward is, how it is triggered) and closes with the routing instruction, all in two sentences. It is slightly promotional in tone ('an agent can EARN', 'no claim, no signup') but every clause carries information, so no real waste.

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 must describe what comes back, and it does: remaining supply broken out per buy-tier and rarity plus the earning steps. Combined with the usage routing and the annotations' safety profile, an agent has everything needed to call it correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless schema applies. The description adds no spurious parameter-like instructions, which is correct.

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 the specific resource (capped-supply collectible NFT minted per $BOBAI buy >= $100) and the specific output (live remaining supply per buy-tier and rarity, plus steps to earn). It also explicitly differentiates itself from the sibling bobai_purchase_guide, so an agent can identify its role without opening the schema.

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

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

It states the exact trigger condition ('use it before a buy of $100 or more to see which NFT it would mint') and names the alternative tool for the actual buy ('for the buy itself use bobai_purchase_guide'). When-to-use and when-to-use-something-else are both explicit.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false), so the description only needs to add context — and it does, disclosing the data provenance (PancakeSwap V2 pair reserves × Chainlink BNB/USD feed, no off-chain price API). It stops short of stating freshness/staleness or caching behavior for the word 'live'.

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

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

Two sentences, front-loaded with the resource and outputs before the routing advice to bobai_liquidity. The parenthetical computation formula is slightly dense but carries trust-relevant meaning rather than filler.

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

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

For a zero-parameter read-only tool with no output schema, the description names what comes back (USD price, BNB price, market cap) and the trust model. Only minor gaps remain — nothing about refresh cadence or failure modes if the pair/feed is unavailable.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter surface for the description to clarify. It correctly adds nothing about 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 verb ('Live $BOBAI price') plus the exact output dimensions (USD, BNB, market cap), and explicitly distinguishes itself from bobai_liquidity. An agent can separate it from bobai_token_info, bobai_dex_info, and bobai_circulating_supply 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?

Gives an explicit use case ('use it for the price now') and an explicit exclusion with the alternative tool and the condition that selects it ('for depth and price impact at a size use bobai_liquidity'). This is exactly the when/when-not/alternative pattern.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'this tool holds no key and moves nothing' plus 'Returns text'. It also discloses the quote/slippage behavior. It stops short of noting rate limits or latency, but for a read-only code generator this is solid added 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-loaded with the purpose, then outputs, then routing, with no wasted preamble. The middle sentence is dense but each clause carries meaning; slightly run-on.

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

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

For a zero-parameter, read-only tool with no output schema, the description states the return type ('Returns text') and the content of the generated code (quote, slippage, fee-on-transfer method name). An agent has everything needed to call it correctly.

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

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

Zero parameters, so there is no schema surface to interpret and the baseline is 4. The description correctly implies a parameterless, self-contained call.

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: it produces ready-to-run viem code for a $BOBAI purchase with BNB on PancakeSwap V2. It explicitly contrasts with the sibling bobai_dex_info ('for the raw parameters only'), so an agent can route without opening either 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?

Explicit when-to-use ('Use it when you want working code') plus a named alternative and its selection condition ('for the raw parameters only, bobai_dex_info'). Nothing is left 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 declare readOnlyHint/destructiveHint, but the description adds substantial context: the signals are live and verifiable, require no API key, draw from an immutable on-chain ledger, and that whale wallets are auto-tracked at a 1%-of-supply threshold with snapshots at multiple horizons. It discloses both the data provenance and the tracking methodology, well beyond the safety hints.

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 resource and its core signals, and each clause maps to a concrete output group, so little is wasted. It is however a single very dense sentence with heavy parenthetical nesting, which slightly hurts readability.

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?

No output schema exists, yet the description enumerates the returned signal groups (tax reserve, whale in/outflows and top movers with tx, daily snapshots with 1d/7d/30d trends, the $100+ buy ledger, burn momentum) and notes verifiability and no-API-key access. An agent has everything needed to decide to call it and interpret results.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4; there is no parameter meaning to add beyond the schema. The description uses the freed space to describe the return composition instead.

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

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

States a specific verb+resource ('Live smart-money signals for $BOBAI') and then enumerates exactly which signals the tool returns: tax-reserve buy pressure, whale flows/holdings, a $100+ buy ledger, and burn momentum. It distinguishes itself from siblings by explicitly naming bobai_activity and bobai_wallet_balance as the tools for adjacent questions.

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

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

Gives explicit when-to-use ('read buy pressure and what large holders do') and names two alternatives with the conditions that select them ('for proof of past burns use bobai_activity, for one wallet's balance bobai_wallet_balance'). No ambiguity about 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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered structurally. The description adds useful context that this is a BEP-20 token on BNB Chain and is 'verified & renounced', plus that identity and supply come back together. It does not cover caching, freshness of supply figures, or rate limits, which keeps it at a solid-but-not-rich 3.

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 dense sentences, zero filler, with the returned-field list front-loaded and the sibling routing pushed to the end. Every clause carries information an agent needs.

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 returned fields, so the agent knows what a call yields. For a parameterless read-only tool, nothing needed 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the 4 baseline applies. The description rightly spends no words on arguments.

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 concrete verb+resource ('$BOBAI on-chain token info') and enumerates the exact fields returned (contract, name, symbol, decimals, total/circulating supply, burned). It explicitly distinguishes itself from bobai_price and bobai_activity by name, so an agent can route 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?

Gives both the when-to-use case ('for the token's identity and supply in one call') and the alternatives with their selecting conditions ('for the price use bobai_price, for the burn history bobai_activity'). No inference is required.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with that. It adds useful behavioral context beyond the annotations: this returns static descriptive/explanatory content rather than live figures, and it carries an advisory disclaimer. It doesn't describe output shape or length, so it falls short of 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?

Front-loaded with the subject and topic list, then scoping and routing. Dense but each clause earns its place (topic coverage, disclaimer, sibling routing). Slightly long for a no-arg explainer, keeping it off a 5.

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

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

For a parameterless knowledge tool with no output schema, the description supplies enough: what it covers, what it is not, and where to go for live numbers. It leaves the exact response format unstated, but that is minor for an explanatory 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 tool takes zero parameters, so the baseline is 4; there is no parameter syntax for the description to clarify and none is needed. No penalty applies since the empty schema is self-explanatory.

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?

Names the specific resource ($BOBAI token value-accrual mechanics) and enumerates the content covered (deflationary tax->buyback->burn design, renounced ownership, LP burned, fair launch). It also explicitly disclaims what it is not (a buy recommendation), which sharpens the purpose rather than muddying it.

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

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

Gives an explicit when-to-use ('explain how the token works, to a user or in a report') and routes the agent to named alternatives for the adjacent need ('for live numbers use bobai_token_info, bobai_activity or bobai_smart_money'). Nothing is left to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful scope context (single-wallet lookup vs aggregate flows), though it does not state the return format or units, which would help for a balance call with no output schema.

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

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

Two tight sentences, zero filler, with the scope constraint and the sibling routing front-loaded. Every clause 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 one-parameter read-only lookup the description is nearly complete, and it names the returned assets. Because there is no output schema, the description could still be stronger on return shape (units, decimals, formatting), which is the only remaining gap.

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% and the single address param is fully documented in the schema (0x + 40 hex chars). The description adds no syntax or format detail beyond what the schema already 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?

States the exact resources returned (BNB and $BOBAI balances) for a specific scope (any BSC wallet address), which is a precise verb-free but unambiguous resource statement. It is clearly distinguishable from siblings like bobai_smart_money and bobai_token_info.

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

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

Explicitly says to use it to check one wallet before or after a trade, and names the alternative (bobai_smart_money) with the condition (whale flows across many wallets) that selects it instead. Nothing is left to inference.

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

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

Annotations already declare readOnlyHint/destructiveHint, and the description adds substantial behavior beyond them: no API key needed, pool figures never cached vs contract properties cached up to 6h, and explicit error semantics ('tax that could not be measured comes back null with a warning, never as 0%' and 'quotable: false with a reason is an answer, not an error'). This is exactly the extra disclosure annotations cannot carry.

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 purpose and then delivers a dense, single-paragraph inventory of every returned field. The content is information-bearing rather than padding, but the run-on wall of text with no structuring is hard to parse and clearly overlong even accounting for the absence of an output schema.

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

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

With no output schema, the description carries the burden of explaining returns and does so thoroughly — cost components, 1% price-impact sizes, measured tax with source, LP custody, holders, flow, venues, and contract properties. For a read-only single-parameter tool this leaves an agent well equipped to interpret results.

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

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

Single parameter at 100% schema coverage, so the schema already documents that the input accepts a token address, pool/pair address, or a BscScan/DexScreener/PancakeSwap link. The description only restates 'ANY token or pool' and adds no format or resolution detail beyond the schema, fitting the baseline 3.

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

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

States a specific verb and resource ('the full honeypot / rug-pull / liquidity read' and 'measure what a trade on BNB Smart Chain would actually cost') for ANY token or pool. It also positions itself relative to the sibling preflight ('behind the preflight'), so an agent can tell it apart from bsc_token_preflight without opening the schema.

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

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

Usage is implied by 'before placing it' and by the reference to being the deeper read 'behind the preflight', which borders on routing. However, no explicit when-to-use vs when-not, and no alternative sibling is named for cases where this is overkill — the agent must infer the relationship to bsc_token_preflight itself.

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

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

Goes far beyond annotations: webhook-only delivery, 15-minute re-read cadence, per-alert trigger conditions, HMAC-SHA256 signing with the x-bobai-signature header and registration-time secret, free/paid quota tiers, and the required signature message format. The write-and-open-world nature of the tool is fully disclosed.

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?

Purpose is front-loaded correctly, but the description is a dense run-on that crams the entire alert taxonomy into stacked parentheses. Highly useful detail, but the structure makes it hard to scan and the alert-condition list is longer than an agent needs for tool selection.

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 complex stateful webhook tool with no output schema, it covers delivery mechanism, signing, lifespan, and where to read status/terms. It stops short of describing the alert JSON payload shape, which an integrating agent would benefit from, leaving a small gap.

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 already 100%, so the schema documents all five fields. The description nonetheless adds real value by giving the exact EIP-191 signing message template ('BOBAI rug watch\nwallet: <lowercase address>\nissued: <issued>') and the holder threshold, which the schema only gestures at.

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?

Opens with a specific verb+resource+scope: 'Rug-pull and honeypot ALARM for a BSC token you hold — webhook only'. It names the delivery mechanism, the polling cadence, and distinguishes itself from siblings by noting it internally re-reads with bsc_token_preflight. An agent can tell exactly what this does without opening the schema.

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

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

Clearly frames the use case ('a BSC token you hold') and rules out alternatives ('no Telegram, no browser, no mail'), plus states quota tiers, the 30-day lifespan, and how to renew. It stops short of an explicit when-to-choose-this-over-X comparison, but the context is strong enough for correct selection.

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

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

Annotations only declare readOnlyHint/destructiveHint; the description carries far more: the stop[]/caution[] split, what each stop fact means, the one-word gate verdict, refusal codes (is_wallet, not_a_token, bad_address, bad_usd) with hints, no caching of pool figures, a 6h GoPlus cache, and the explicit statement that it cannot see an owner who has not acted and returns no 'safe' score.

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 opening two sentences are well front-loaded, but the body is an extremely dense block that enumerates nearly every return field and edge case in one paragraph. Much of the detail belongs in an output schema or docs, and the sheer length impedes fast tool selection.

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

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

There is no output schema, so the description must explain returns — and it does thoroughly: the stop[]/caution[] structure, the figure/value/line/unit convention, the gate verdict, refusal shape, and which sibling tools back each figure. For a 2-param preflight tool this is complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds genuine semantic weight beyond the schema by repeatedly stressing that results are measured at "YOUR size" (per-side slippage needed, 1% depth, round-trip tax at this size), which explains why the usd parameter materially changes the answer.

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 up front: "Honeypot and rug-pull pre-trade check, measured not labelled." It defines scope (any BSC/BNB Smart Chain token) and explicitly positions itself relative to siblings by naming bsc_pool_scan and pancakeswap_best_route as the underlying data sources and routing launch-curve tokens elsewhere.

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?

"For an agent about to trade ANY token on BNB Smart Chain: the check to run before every trade, in one call and at YOUR size" gives an unambiguous when-to-use trigger. It also names the alternative for tokens on a four.meme curve, so the agent knows when this tool is the wrong entry point.

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 mark this as readOnly and non-destructive, so the description's added value is its live behavior: it contacts ERC-8004 agents, checks whether they actually answer, and matches against the tools they return and their on-chain descriptions. It also sets expectations by rejecting self-reported categories and curated lists, which helps the agent interpret results.

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 opens with the core purpose and then adds methodology, expectations, and usage guidance in four short sentences. Each clause carries distinct information, and there is no filler or repetition.

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

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

For a low-complexity read-only search with one required and one optional parameter, the description gives enough context to select and invoke the tool correctly: what it searches, how it verifies, and when to use it. No output schema exists, but the return behavior is implied by the purpose and the annotations cover the safety profile, so there is no material gap.

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 covers 100% of parameters, including query examples and the 'speaks' protocol constraint, so the baseline is 3. The description's phrase 'can do a given thing' mirrors the query parameter without adding syntax, formats, or validation beyond 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 first sentence states a specific action ('find') and resource ('AI agents on BNB Smart Chain that can do a given thing'), making the core purpose unambiguous. The second and third sentences sharpen the definition by describing the live-verification method and explicitly distinguishing this search from self-reported or curated lists, which separates it from related agent tools like bnb_agent_census and bnb_agent_employment.

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 last sentence provides explicit placement guidance: use this tool before assuming no agent exists for a task. It does not name sibling tools to use instead or state exclusions, so it falls just short of an explicit when/when-not/alternatives rule.

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 readOnlyHint=true and destructiveHint=false annotations present, the bar is lower, yet the description still adds substantial behavioral context: it explains that quoted prices come from the venue itself, that the transfer tax is applied between legs because it is taken outside the pool where quoters cannot see it, and that the tool cannot detect an owner who has not acted yet. These are genuine disclosures beyond the annotations, with no contradiction.

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

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

The description is well-organized with FIRST/SECOND structure and front-loads the core purpose, but it is long and occasionally stylistic ('where no quoter can see it', 'and it says so') where plainer wording would do. Every sentence carries some information, yet the prose is denser than necessary for an AI agent to parse 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?

There is no output schema, so the description carries the full burden of explaining return values, and it does: best route, cost of every other route, round-trip with and without tax, and required slippage. It also covers the tool's limitations and the two questions it answers, leaving an agent with a complete picture despite medium-high complexity and no structured output 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 baseline of 3 applies. The description reinforces the meaning of 'usd' by referencing 'this size' and slippage at size, but it adds no parameter-specific syntax or format details beyond what the schema already documents. It is adequate, not additive.

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

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

The description states a specific verb and resource: it determines the best route for a PancakeSwap swap, selecting among up to five pools by actual quoted return at the given size rather than by depth. It also distinguishes itself from nearby siblings like pancakeswap_fee_tiers, pancakeswap_range_plan, and bsc_pool_scan by framing itself as the pre-signing route/slippage decision tool for a swap.

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 opening clause 'For an agent about to swap on PancakeSwap' gives a clear trigger condition, and the closing warning 'It is not a safety certificate' tells the agent when not to rely on it. It does not name specific sibling alternatives to use instead, but the context is strong enough that the intended placement is unambiguous.

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 only readOnlyHint/destructiveHint on the annotations, the description carries real behavioral weight and delivers: a 60-second edge cache with cache.hit and cache.age_seconds, a ~1-hour measured (never annualised) window, dual denominators including a 2% tick-book reconstruction, and the fact that stale-but-funded tiers are reported. It stops short of failure modes or a full return-shape statement, so 4 rather than 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?

It is front-loaded with the use case before the methodology, and most sentences carry information. But it is a single dense paragraph of ~230 words for a one-parameter tool, with editorial asides ('which does not say which one pays', 'every interface shows') that inflate length without adding call-relevant facts.

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 methodologically complex tool with no output schema, so the description must explain returns; it names swaps, turnover, realized fees, fees per $1,000, both rankings, and the cache fields, and it discloses the measurement window. That is close to complete, though it does not enumerate the full response shape or error behavior.

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?

One parameter with 100% schema description coverage ('A BSC token address, or a PancakeSwap pool address to pin the pair'), so the schema already carries the semantics. The description explains the pair/pool context around the token but adds no syntax, format, or token-vs-pool behavioral detail beyond the schema; 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 domain and measurement: a LP choosing where to place liquidity, and the tool measures each fee tier (V2 0.25%, V3 0.01/0.05/0.25/1.00%) over a live window with swaps, turnover, fees and fees-per-capital. That is a concrete verb+resource (rank PancakeSwap fee tiers for a pair), but it is delivered as a narrative rather than a crisp statement, and it never distinguishes itself from siblings like pancakeswap_position_look, pancakeswap_range_plan or bsc_pool_scan.

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 opening clause 'For a liquidity provider deciding WHERE to put liquidity' implies the use case, and it says both rankings are returned because they disagree. However, no explicit alternatives are named and there is no when-not guidance, so the agent must infer when this beats 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?

Annotations already declare readOnlyHint=true/destructiveHint=false, and the description adds meaningful extra context: it reads directly from the chain, is free, and reports whether collecting fees covers gas. These operational traits go beyond the safety hints, though it omits latency/rate-limit behavior.

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

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

The core purpose is front-loaded, but the single dense paragraph packs in tangential material (the The Flip 88% proposal, pricing in USD1/$BOBAI, agent id ERC-8004 #363709) that dilutes the read-only tool's core function. Every clause is informational but the size is heavy for a 2-parameter lookup.

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-value burden and does so thoroughly - range position, edge room, holdings, fees, gas comparison, and Flip impact. Input modes are also covered. Error/empty-wallet handling is the only notable omission.

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 baseline is 3, and the description adds real semantics: the 'position' is the NFT token id, and passing a wallet returns the ids of all positions it holds. That multi-result behavior is not captured 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?

States a specific verb ('look at / read from the chain') and resource ('any PancakeSwap V3 liquidity position on BNB Chain'), and enumerates the concrete facts returned (range status, edge room, holdings/value in BNB, owed fees, gas breakeven). It is easily separable from siblings like pancakeswap_range_plan or bsc_pool_scan.

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

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

Explicitly describes the input modes ('give a position id, or a wallet that holds one') and routes the recommendation side ('what to do about it - whether a re-set is due and in which width') to the paid plan. It gives clear context but does not name the specific sibling tool (e.g. pancakeswap_range_plan) that fulfills the paid path.

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 mark this read-only and non-destructive; the description goes further by explaining the replay mechanism, explicit exclusions (no modeling, no forecasting, no impermanent loss), the live window of about an hour, and the caveat that it is worst exactly where fees are best. This is substantial behavioral disclosure beyond 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 description is compact but somewhat ornate, especially the opening clause about concentrated liquidity forcing the decision. Most sentences add a distinct, useful point, and the key outputs and caveats are front-loaded enough for an agent to grasp quickly.

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

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

There is no output schema, but the description enumerates the main returned values: fees collected, time in range, and number of walk-outs. It also covers limitations and temporal scope, giving an agent enough context to understand the result shape, though exact output formatting is not specified.

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 all three parameters. The description provides conceptual mapping such as 'position of a stated size' to capitalUsd, but it does not add meaningful parameter semantics beyond what the schema fields already describe.

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 explains an analytical function: it replays historical V3 Swap events through a position of a given size and reports fees and in-range behavior per candidate price range. It is detailed enough to distinguish it from route/fee-tier siblings, though it never explicitly names an alternative tool.

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 a clear context for when to use the tool: a liquidity provider has already chosen a PancakeSwap V3 pool and now needs to choose a price range. It does not explicitly compare against siblings or state when not to use it, but the intended decision scenario is well-defined.

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