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

No annotations exist, but the description carries real weight: it discloses that the tool only returns unsigned calls plus a wallet_sendCalls batch (no signing), that identity and pass mints may be inserted before the buy, the ~$0.01 Base gas estimate, and an 'unaudited' risk warning. It stops short of stating irreversible on-chain effects or failure behavior if a prerequisite fails.

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?

Everything is packed into one front-loaded sentence with the core action first, then the flow, then cost and risk. Dense but zero filler; the arrow notation is readable and the caveats are correctly placed at the end.

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 six-parameter orchestration tool with no annotations and no output schema, the description explains the sequencing, the artifact returned (ordered unsigned calls plus batch), the chain, and the risk posture. The main remaining gaps are return shape details and the meaning of referrer/slippagePct.

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?

At 67% schema description coverage, the schema already documents wallet, eth, token, and agentId; the description only restates the token default (APBUILD). referrer and slippagePct remain undocumented in both places, so the description does not compensate for the coverage gap.

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

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

The description states a specific verb and resource ("buy an AgentPad token on its bonding curve") and describes the exact orchestration it performs (prerequisite checks, ordered unsigned calls, EIP-5792 batch). It never names the overlapping siblings build_buy_tx or onboard_and_buy, so an agent must infer the difference rather than being told.

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?

"ONE tool" and the description of the full mint-then-buy flow imply this is the one-shot path, but there are no explicit 'use this when / use X instead' statements. With build_buy_tx, onboard_and_buy, and quote_buy all plausibly relevant, the routing decision 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?

No annotations are provided, so the description must carry the behavioral burden. It implies a read-only informational response by listing 'Fees, contracts, docs, totals,' but it does not explicitly state that there are no side effects or describe the return format.

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 compact sentence with the key resource and content areas front-loaded. The closing list 'Fees, contracts, docs, totals' is slightly abrupt, but there is no significant wasted text.

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 informational tool with no output schema, the description is reasonably complete: it names the platform and summarizes the categories of information returned. It could be stronger by explicitly stating that it returns metadata/documentation rather than taking actions.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The baseline score of 4 is appropriate because the description does not need to compensate for any input schema gaps.

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

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

The description identifies the resource as AgentPad v2 and lists content areas such as fees, contracts, docs, and totals, but it does not use a clear verb like 'returns' or 'retrieves'. It also does not explicitly distinguish this informational tool from sibling lookup tools like get_roadmap or get_token.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as get_roadmap, get_token, or list_tokens. An agent can infer it is for background information, but the description provides no when-to-use or when-not-to-use conditions.

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

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

With no annotations, the description carries the full burden. It helpfully discloses the returned fields, including v2 and v1 claimable earnings, but does not state that it is read-only, whether any authentication is required, or how 'Pass' and identity age should be interpreted.

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 short and front-loads the core question. The return-field fragment is useful, though the telegraphic phrasing and ambiguous 'Pass' slightly reduce clarity.

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

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

For a simple read-only status query with no output schema, listing the returned fields is valuable. However, the description omits the wallet input format and sufficient context about v2/v1 earnings and identity age semantics.

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

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

Schema description coverage is 0% for the single required wallet parameter. The description only says 'this wallet' and does not specify address format, chain, or any other constraint, so it adds little beyond the parameter name itself.

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

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

The description clearly states the tool checks whether a wallet is a registered AgentPad agent and enumerates the status fields returned (Pass, identity age, traded flag, claimable earnings). It is distinguishable from transaction-building siblings, though it does not explicitly contrast itself with check_vote_eligibility or agentpad_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?

The question form implies this is used to check registration status, but there is no explicit guidance on when to use it versus alternatives such as check_vote_eligibility or agentpad_info. No exclusions or preconditions are provided.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that this returns an unsigned transaction and is permissionless, and it defines the triggering failure conditions. However, for a burn operation it does not explain what is actually destroyed, whether the action is irreversible, or what the transaction changes.

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

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

The description is a single front-loaded sentence with no wasted words. The key qualifier (unsigned tx, anyone) and the eligibility condition are stated immediately.

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

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

The tool has no annotations, no output schema, and 0% schema description coverage. The description covers the purpose and trigger conditions, but it leaves out parameter meaning and the actual effects of burning a failed tranche, so an agent lacks enough context to call it confidently.

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

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

Schema description coverage is 0%, so the description must define the two required parameters. It references a token and a failed tranche, but it does not explicitly explain what token should contain or what milestone means, nor does it document format or constraints.

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

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

The description states a specific verb and resource: it builds an unsigned transaction to burn a failed tranche. It also gives the defining conditions (deadline passed or token did not graduate within 60 days), which lets an agent distinguish this burn operation from the other build_*_tx siblings.

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

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

It clearly states when the tool applies: the tranche is failed because its deadline passed or the token did not graduate within 60 days. It also notes that anyone can invoke it. It does not mention alternatives or exclusions, but the usage context is explicit enough.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses that the output is an unsigned tx, that v1 and v2 tokens are both supported, and exactly what the opt-in preflight covers (agent pass, ETH balance, eth_call simulation, problems, next step). It omits what happens when wallet is omitted (no preflight at all?) and never describes whether the tx must be signed before a deadline or how the preflight result is shaped.

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

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

Three compact sentences (or one long one) leading with the core action, then eligibility, then the optional preflight. The parenthetical list of preflight checks is dense but earns its place; nothing is 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 tx-builder with no annotations, no output schema, and thin schema coverage, the definition covers intent and the preflight behavior but leaves critical gaps: the unit/nature of `eth`, the slippage default and its effect on the curve price, and the shape of the returned unsigned tx. An agent could plausibly mis-call this with a wrong `eth` value.

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 only 25%, so the description must compensate, and it only elaborates on `wallet`. `token` is loosely implied, but `eth` is a bare string with no unit or format (amount vs address? wei vs decimal?) and `slippagePct` is never mentioned in the description or the schema, including any default when omitted.

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 gives a specific verb plus resource: it produces an unsigned buy transaction for an AgentPad token on its bonding curve. It also scopes the operation with 'registered agents only before graduation' and v1/v2 support. It never names siblings like quote_buy or agentpad_buy, so sibling differentiation is left to the agent.

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 an eligibility constraint ('registered agents only before graduation') and what the optional wallet adds, which implies when to pass it. But it never says when to use this rather than quote_buy (to price) or agentpad_buy (to execute), so the choice among the ~20 siblings 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?

With no annotations, the description carries the full burden, and it delivers the two most important facts: the result is an 'Unsigned tx' (not an executed action) and invoking it 'opens the agent vote' (a state-changing side effect). It omits auth/permission mechanics and any indication of what the caller does with the returned tx.

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

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

A single front-loaded sentence that packs scope, action, and consequence with no filler. Nothing is wasted and the key noun phrase ('Unsigned tx') comes first.

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

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

For a 3-required-param tx builder with no annotations, no output schema, and 0% schema coverage, the description is thin: it never identifies the 'token' param, doesn't say the tx must be signed and submitted separately, and gives no error or eligibility conditions. Adequate for the core action but incomplete for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it only partially does: 'proof link' maps to proofURI and 'milestone' is named, but the required 'token' parameter is never mentioned or explained. Two of three params are loosely illuminated.

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 ('claim a VOTE milestone as done with a proof link') and adds the team-member scope plus the side effect ('opens the agent vote'). This distinguishes it clearly from build_release_milestone_tx and build_vote_tx, though the wording 'claim a VOTE milestone as done' is slightly compressed.

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 '(team members)' qualifier implies who should call it, which is useful context. However, it never names an alternative or states when NOT to use it (e.g., versus build_release_milestone_tx or build_finalize_vote_tx), leaving the routing to inference.

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

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

With no annotations, the description carries the full burden. It does disclose a key behavioral trait: the output is an *unsigned* transaction (not a submission). But it omits auth requirements, whether the build step is side-effect free, what happens if no fees are owed, and the return payload shape.

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

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

One front-loaded sentence starting with the critical 'Unsigned tx:' qualifier, then the action, then the parameter note. No filler; 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 tx-builder with no annotations or output schema, the description covers purpose, unsigned nature, and the pad default, but leaves gaps: no return format, no preconditions (accrued fees, wallet context), and no error behavior. Adequate but not complete.

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

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

Schema coverage is 0% and the single optional enum parameter `pad` is otherwise undocumented. The description compensates well by explaining that `pad` selects v2 (the default) or v1, adding default semantics beyond the bare enum.

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 action (build an unsigned transaction to withdraw accrued creator/team/referral fees), which clearly distinguishes it from other build_* siblings like build_buy_tx or build_claim_milestone_tx. The only shortfall is that it doesn't explicitly contrast with the closest sibling, build_claim_milestone_tx.

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: call this when you need to withdraw earned fees. However, there is no explicit when-to-use vs alternatives guidance, no prerequisites (e.g., must have accrued fees), and no note on what to do with the resulting unsigned tx.

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

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

With no annotations, the description carries the load and discloses permission ('anyone'), success criteria (quorum + yes > no), and failure/retry behavior ('team can retry after a cooldown'). It stops short of explaining that the unsigned tx must be signed and sent, or what state change closing causes.

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 core action and permission, then the outcome rule. 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?

Lacks any parameter explanation and doesn't describe what the unsigned transaction contains or requires for signing. Given no output schema and no annotations, this is inadequate for correct invocation.

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

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

Schema description coverage is 0% and the description never mentions 'token' or 'milestone'. For a 2-parameter tool with no schema documentation, this leaves the agent without meaning for either required field.

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 ('close a vote') and resource, and the 'Unsigned tx (anyone)' framing distinguishes it from execution tools and voting siblings. An agent can tell it builds a transaction to finalize a vote, not to cast one.

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?

Specifies the condition 'after it ends' and the outcome rule, giving clear context for when to use. It does not name alternatives like build_vote_tx or list_open_votes, but the timing condition is explicit.

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

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

With no annotations, the description carries the full burden and does well: it discloses the unsigned nature, launch fee of 0, that initialBuyEth is optional, the 5% creator allocation schedule, and the 0.50% creator trade fee. What is missing is operational context such as approval/gas requirements and whether any preconditions (e.g., valid metadata fetch) can make the call fail.

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?

Four sentences, all load-bearing, with the critical v1-disabled/v2-only constraint front-loaded ahead of economics. No filler or restatement of the tool name.

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 mutation-style transaction builder with no annotations and no output schema, the description covers target version, fees, and economics well. It omits what the returned unsigned transaction looks like (fields to sign, chain id, gas) and the initialBuyEth semantics, which an agent needs to complete the flow.

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 only 25% (only metadataURI is documented), so the description should compensate more than it does. It clarifies that initialBuyEth is optional, but leaves its unit and format (wei vs. decimal ETH string) undefined, and adds nothing about name/symbol beyond the schema's length constraints.

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

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

The description uses a specific verb and resource ("Unsigned tx: one-call solo launch on AgentPad v2") and pins down the exact variant: solo, default roadmap. That implicitly separates it from build_team_launch_tx among the siblings, so an agent can choose 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 clearly says when to use it (AgentPad v2 only, because "v1 launches are disabled on-chain; APAD/v1 tokens still trade"), which prevents a wrong-target launch. It does not name build_team_launch_tx or onboard_and_buy as the alternatives for team launches or launch-and-buy flows, so routing is left partly to inference.

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

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

With no annotations, the description does carry useful load: it discloses the output is an unsigned transaction (nothing is broadcast), the cost model ('free, gas only'), the 30-day pass duration, and the one-agentId-one-vote constraint. It omits what to do with the tx afterward and whether the call fails or no-ops on re-registration.

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, front-loaded with the output type and the core action. The identity/vote clause is short and materially informs the caller rather than 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?

For a tool with no annotations, no output schema, and 0% schema coverage, the description leaves too much open: 'referrer' is undocumented, the shape of the returned unsigned tx is unstated, and downstream submission is not addressed. It covers the economics but not the mechanics an agent needs to invoke and use the result.

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

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

Schema description coverage is 0%, so the description must compensate. It only implies that agentId is an ERC-8004 token the caller owns on Base; the optional 'referrer' parameter is never mentioned at all, leaving half the inputs undefined.

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

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

States a specific verb+resource: build an unsigned transaction that registers the caller as an AgentPad v2 agent using an ERC-8004 agentId. The 'build_*_tx' prefix plus the explicit ERC-8004 framing distinguishes it from spend-related siblings like build_buy_tx or build_vote_tx, though no sibling is named directly.

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 a real prerequisite ('an ERC-8004 agentId you own on Base'), which helps an agent decide eligibility. But it never says when to choose this over adjacent tools (onboard_and_buy, agent_status) or what happens if the wallet is already registered.

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

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

With no annotations, the description does carry real weight and it delivers two useful traits: the output is an unsigned transaction (not a submitted one) and the call is permissionless. It omits failure behavior, idempotency, and whether the milestone must be confirmed met — significant gaps for a state-touching builder.

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

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

A single sentence with no filler, and the key fact (unsigned tx) is front-loaded. The parenthetical conditions are dense but readable; slightly more structure would help, but nothing is wasted.

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

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

No annotations, no output schema, and 0% parameter documentation mean this short sentence carries the full burden. It does not say what the caller should do with the unsigned tx (sign/submit), how to identify the milestone, or how it differs from the sibling claim builder.

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

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

Schema description coverage is 0% for both parameters. The description hints that 'milestone' selects a tranche but never explains indexing (schema min is 0), and the 'token' parameter is never mentioned at all. With no schema documentation to fall back on, the description should compensate and does not.

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 and resource ('release a met milestone tranche to the team') plus the preconditions, so the agent knows this builds a release transaction rather than a claim. It never names the closest sibling (build_claim_milestone_tx), so the distinction still requires inference, keeping it below a 5.

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

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

The parenthetical '(after graduation + 3-day cliff)' implies the gating conditions for use, and '(anyone)' signals permissionless access. But there is no explicit statement of when to choose this over build_claim_milestone_tx or what to do if the milestone is not yet met.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the output is an unsigned transaction and that selling happens back to the curve with a whole-token amount, but it omits permissions, approval requirements, slippage behavior, and what v1/v2 means.

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 short, front-loaded, and free of filler. However, the trailing 'v1 or v2' is cryptic and does not clearly earn its place without further explanation.

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 transaction-building tool with zero annotation coverage, 0% schema description coverage, and three parameters, the description is too thin. It lacks token format, slippage semantics, version behavior, and any relation to quote_sell or approval flows.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'amount' is a whole-token amount, which is valuable, but it says nothing about the 'token' parameter format (e.g., mint address) or the optional 'slippagePct' parameter.

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

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

The description states a specific action and resource: build an unsigned transaction to sell AgentPad tokens back to the curve. It implicitly distinguishes this from buy tools by naming the sell direction, but it does not explicitly distinguish itself from siblings such as quote_sell.

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

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

There is no guidance on when to use this versus quote_sell, agentpad_buy, or other build_* transaction tools. The phrase 'v1 or v2' is not explained, and no prerequisites or exclusions are given.

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

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

With no annotations provided, the description carries the full burden and discloses key behavior: the transaction is unsigned, must be sent from the lead wallet, and enforces team size, share rules, and milestone constraints. It stops short of explaining error behavior, idempotency, or what happens when constraints are violated.

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 and front-loads the key platform constraint and transaction type. It is a dense run-on sentence that could be better structured with bullets for team and milestone rules, but no sentence is wasted.

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

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

For a complex 7-parameter transaction builder with no annotations and no output schema, the description covers the main launch intent, team, and roadmap constraints. It still leaves important gaps around initialBuyEth, metadataURI, and the exact meaning of lead/name/symbol in the launch process.

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 only 29%, so the description must compensate. It adds meaningful constraints for team (up to 5 registered agents, fixed shares, lead gets the rest) and milestones (1-5, shares sum 100, GRADUATION <=30%, VOTE <=50%, PRICE >=1.5x), but it leaves lead, name, symbol, metadataURI, and initialBuyEth largely or entirely unexplained.

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

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

States a specific verb and resource: launch on AgentPad v2 with a TEAM and a custom roadmap, producing an unsigned tx. It distinguishes itself from the likely solo-launch sibling by emphasizing 'TEAM', but it does not explicitly name build_launch_tx or spell out the alternative.

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

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

The sentence 'AgentPad v2 is the ONLY launch target' gives a platform constraint, and 'Send from the lead wallet' is an operational instruction. However, it never explicitly says when to choose this tool over build_launch_tx or other build_* transaction tools.

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

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

With no annotations, the description carries the burden and does disclose key traits: it returns an 'Unsigned tx' (not an executed vote) and that voting is one-per-milestone and not token-weighted. It omits eligibility/auth prerequisites, what to do with the unsigned payload, and whether a vote is final or changeable.

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

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

A single terse line with the operation and key constraints front-loaded and zero filler. It is efficient, though the extreme brevity leaves out details that would earn 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 3-param transaction builder with no annotations and no output schema, the description conveys the unsigned-tx nature and voting semantics but omits the token param, eligibility requirements, and downstream signing step. Adequate but with clear gaps.

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

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

Schema coverage is 0% with 3 params, so the description must compensate. It clarifies 'yes/no' for the support boolean and references the milestone, but the required 'token' parameter is entirely unexplained, leaving real gaps.

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

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

States a specific action (build unsigned tx to cast a vote) on a specific resource (a VOTE milestone), and the 'not token-weighted' note carves out a distinct semantic from other vote-related siblings. It doesn't explicitly name competitors like build_finalize_vote_tx, so it's clear but not sibling-differentiating to the top level.

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?

'cast your ONE vote (yes/no) on a VOTE milestone' implies the use case, but it never says when to prefer this over build_finalize_vote_tx or that check_vote_eligibility should be run first. Usage is inferable but no explicit alternatives or prerequisites are given.

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

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

No annotations exist, so the description carries the full burden. It does disclose return semantics ('returns the reason if not'), which is valuable non-structured information, but it never states that this is a read-only/non-mutating call, whether it errors versus returning a falsy result, or what inputs (e.g. token address vs symbol) it expects.

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, zero waste, with the core question front-loaded and the return hint second. Nothing could be removed without losing meaning.

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

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

For a tool with no annotations, no output schema, and three fully undocumented parameters, the description is too thin. It leaves the token parameter, input formats, and the shape of a positive versus negative response unexplained.

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

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

Schema coverage is 0% and all three parameters are bare strings/integers. The description mentions 'wallet' and 'milestone' only in passing and says nothing about the 'token' parameter, expected address formats, or whether milestone is an index or ID, so it does not compensate for the schema gap.

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

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

The description states a specific check (vote eligibility) on specific resources (wallet, milestone) as a direct question, which is unambiguous. It does not explicitly name the sibling it complements (build_vote_tx) or distinguish itself from list_open_votes, so it stops short of 5.

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

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

Use is only implied: 'now' hints this is a pre-flight check before calling build_vote_tx or build_finalize_vote_tx, but the description never says when to call it versus those siblings or what to do with a negative answer. An agent must infer the workflow.

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

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

No annotations are provided, so the description carries the full burden. Describing the returned data implies a read-only operation and gives a useful preview of the payload, but it doesn't state behavior for non-v2 tokens, unknown addresses, or missing roadmaps.

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

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

A single dense sentence with zero filler, front-loading the resource and then the returned contents. It reads as a fragment rather than a complete sentence, but nothing is wasted.

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

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

With no output schema and no annotations, the description does the heavy lifting by enumerating the return fields (allocation, milestone kind/share/deadline/status/vote tally, TWAP vs graduation price). Only the input expectations and failure modes are left unstated.

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

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

Schema coverage is 0% for the single 'token' parameter, so the description must compensate. It does add that the token is a v2 token, implicitly constraining the input, but gives no format (address vs symbol) or validation detail.

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 (the roadmap of a v2 token) and enumerates what it contains: locked allocation, milestones, TWAP vs graduation price. It is clearly distinct from siblings like get_token or list_open_votes, though it never explicitly says 'retrieves'.

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

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

There is no guidance on when to call this versus get_token, list_open_votes, or check_vote_eligibility. The agent must infer usage from the returned-fields list alone.

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

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

No annotations exist, so the description carries the full burden. It implies a read but never says so, and it omits failure behavior for a bad/nonexistent token, whether data is on-chain vs cached, and what 'v2' gating means for callers expecting team/milestone 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?

One short sentence with no filler. The parenthetical '(v2)' is slightly cryptic but doesn't bloat the text.

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 and no annotations, so the description should sketch the return shape; 'curve state' plus team/milestones is a start but leaves the fields opaque. Adequate to identify the tool, not adequate to call it confidently.

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

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

Schema coverage is 0% and the single parameter 'token' is undocumented. The description says 'one AgentPad token' but never clarifies whether the value is an address, symbol, or numeric id — the one detail an agent most needs before calling.

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 ('Curve state of one AgentPad token') and the extra data returned (team, roadmap milestones), which distinguishes it from list_tokens and get_roadmap. No explicit verb, but 'state of one token' is unambiguous enough to act on.

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 statement of when to call this versus list_tokens or get_roadmap, no prerequisites, no note about what happens for an unknown token. The agent must infer that this is the single-token lookup.

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

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

With no annotations, the description carries the full burden and discloses data provenance, exact event filtering, last indexed block, curve balance mismatch flags, fee reconciliation, creator_traded statuses, and sample size on verdicts. This is unusually rich behavioral context for a read/analysis tool.

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

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

The description is a dense run-on plus an 'Also (Oct 25)' addendum packed with parenthetical metric definitions. It is front-loaded, but the overloaded list and version note make it hard to parse quickly.

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

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

For a complex multi-metric tool with no output schema or annotations, the description enumerates returned metrics and caveats such as 'unknown', 'not_traced', and sample size. It lacks response structure and error behavior, but is largely complete enough to invoke correctly.

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

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

The single optional token parameter has 0% schema coverage, but the description supplies its format (symbol or 0x) and omission semantics (platform-wide versus per token). It does not explain invalid-token handling, but it compensates well for the schema gap.

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

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

Names a specific computation (AgentPad volume from on-chain Trade events) and enumerates the metrics and scope (platform-wide plus per token). It is clear what the tool returns, but it does not differentiate itself from sibling tools such as token_transparency.

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

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

There is no explicit when-to-use or when-not guidance and no alternative tool is named. The optional token scope explains parameter behavior, but an agent must infer when to choose this tool from its purpose alone.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It names the poll fields that appear in results, but does not state that the operation is read-only, whether it requires auth, whether it paginates, or whether it returns all open votes.

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 compact phrase with no filler, and the field list is front-loaded after the resource. It is terse but not padded; the missing verb is an under-specification issue rather than wasted text.

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 parameters, no annotations, and no output schema, the description should tell the agent what a call returns and when to use it. It lists expected fields, which partly compensates for the missing output schema, but it omits the return container (list), pagination/scope, and sibling routing.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly does not need to explain parameter semantics, and the empty schema aligns with that.

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 resource (open one-agent-one-vote polls on v2 roadmap milestones) and enumerates poll fields, but it is a noun phrase that never states the action 'list' or 'return'. The name supplies the verb, so the purpose is inferable, but the description alone does not clearly distinguish this from related read tools like get_roadmap or check_vote_eligibility.

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

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

There is no explicit guidance on when to call this tool, when not to, or which sibling to use for related tasks. An agent must infer that this is for discovering open votes before calling build_vote_tx or check_vote_eligibility.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely useful behavioral trait: the result ordering (v2 newest first, then v1). However it says nothing about permissions, whether the list is exhaustive or paginated, or what a token record contains.

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

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

One short, front-loaded sentence with zero filler. It is efficient, though the brevity edges toward under-specification rather than tight concision.

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?

A list tool with no annotations and no output schema needs the description to cover pagination, defaults, and result shape; it covers only ordering. An agent still cannot determine how much of the token set it will receive.

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

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

Schema description coverage is 0% and the single parameter (limit, 1-50) is never mentioned in the description. The bound of 50 and the default page size are left entirely unexplained, so an agent cannot tell whether omitting limit returns everything or a truncated default.

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 (List) and resource (AgentPad tokens) and adds a distinguishing scope detail: v2 tokens come newest first, then v1. An agent can tell this is a bulk enumeration tool rather than a single-token fetch like get_token, though the description never names that sibling 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?

No when-to-use guidance, no exclusions, no mention of when to prefer get_token or the buy/quote tools. The word 'List' implies enumeration, but the agent must infer the use case entirely.

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

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

No annotations are provided, so the description carries the full disclosure burden. It reveals that an identity mint occurs and that Bankr /wallet/submit bodies are sent per call, which is useful, but it never states that ETH is spent or transferred, whether the mint is irreversible, what approvals are required, or what failure modes look like. For a value-transferring mutation tool with zero annotation coverage, this is a substantial gap.

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

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

Two compact sentences, front-loaded with the key differentiator before the usage condition. Little wasted text, though the 'per-call Bankr /wallet/submit bodies' clause is opaque shorthand that may confuse rather than inform.

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?

A no-annotation, no-output-schema tool with 7 parameters that spends ETH and mints an on-chain identity needs far more than two sentences: cost, reversibility, prerequisites, and return/result shape are all missing. The agent can only guess what a successful call yields.

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 71%, so most parameters are already documented. The description adds context for agentURI (custom registration file for the mint) and hints at a per-call submit body, but says nothing about token, referrer, slippagePct, or how agentId interacts with the mint path. 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 name plus 'Same as agentpad_buy, plus a custom ERC-8004 agentURI for the identity mint' conveys that this is a buy-and-register composite, but the core action is defined only by reference to a sibling. An agent must read agentpad_buy to learn what the primary operation actually is. It distinguishes itself from siblings but only relative to them, not absolutely.

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?

'Use when your wallet is new to AgentPad' gives one clear positive selection condition and implicitly routes existing wallets to agentpad_buy. There are no explicit exclusions, prerequisites (funding, approvals), or note about what happens if the wallet is already registered.

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

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

With no annotations, the description carries full behavioral burden. It implies a read-only quote but does not explicitly state side effects, permissions, or error conditions. It mentions v1/v2 tokens but lacks details on curve behavior or return format.

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

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

The description is a single, efficient sentence with no wasted words. However, its terseness borders on under-specification for a tool with no other documentation.

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

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

Given no output schema, no annotations, and 0% schema coverage, the description is incomplete. It does not explain the return value (e.g., amount as string), potential errors, or how the curve version is determined.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies that 'eth' is an ETH amount and 'token' refers to a v1 or v2 token, but does not specify format (e.g., wei vs ether, address vs symbol) or other constraints.

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

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

The description states the tool computes tokens out for a given ETH amount on a bonding curve, specifying v1 or v2 token support. It clearly identifies the operation (quote buy) and resource, though it does not explicitly differentiate from sibling tools like quote_sell.

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

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

No guidance is provided on when to use this tool versus alternatives such as quote_sell or build_buy_tx. The description only describes the calculation, leaving usage context implicit.

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

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

No annotations are provided, so the description must carry the behavioral burden. It implies a read-only quote by saying 'ETH out', but never explicitly states that this does not execute a trade, how the quote is derived, or whether it reflects current curve state.

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

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

A single sentence with no wasted clauses, but the phrasing 'ETH out' is awkward and front-loads an ambiguous output concept rather than the action. It is concise but not as clear as it could 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?

For a quote tool with no output schema and no annotations, the description should clarify that it returns an ETH estimate and that it is non-mutating. Those essentials are missing, leaving the agent to infer the core contract.

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

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

Schema description coverage is 0%, so the description must compensate. It adds that 'amount' is a whole-token amount and that the token can be v1 or v2, but it leaves the string format for token and amount (address? id? decimals?) completely unexplained.

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

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

The phrase 'ETH out for selling a whole-token amount on the curve' implies a sell-quote operation, and the token/amount context is clear. However, it never explicitly says it returns a quote, and the v1/v2 parenthetical is cryptic; an agent has to infer the purpose from the tool name more than from the description.

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

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

No guidance on when to use this versus quote_buy, build_sell_tx, or agentpad_buy. It doesn't state prerequisites such as token validity, curve state, or whether this is a dry-run quote versus an executable action.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavioral traits: data is read live from Base, the feeRecipient is read from the contract, verdicts carry an 'n' sample size, balance checks are against a named block with a two-sided MISMATCH flag, and contracts are explicitly UNAUDITED. These are exactly the caveats an agent needs before presenting results as authoritative. It does not state read-only semantics explicitly, nor failure modes for an unknown symbol, keeping it below 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 entire description is one sprawling run-on sentence that dumps roughly a dozen output categories without grouping, hierarchy, or front-loading of the most important facts. The UNAUDITED caveat, arguably the most critical detail, is buried at the very end. It is informative but structurally poor and hard to scan.

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

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

There is no output schema, so the description must explain the return surface, and it does so thoroughly: fee routing, ownership, upgrade timelock, verification links, unlock timing, graduation liquidity, volume, net flows, balance/mismatch checks, fee reconciliation, creator_traded states, and milestone logs. The main gaps are error/unknown-token behavior and any notion of output shape (flat vs nested).

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

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

The single 'token' parameter is fully documented in the schema as 'symbol (APBUILD, APAD) or 0x token address', so coverage is 100%. The description adds no further semantics about the parameter, such as case sensitivity or behavior on ambiguous symbols. Baseline 3 is appropriate when the schema does the work.

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

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

The description opens with a specific framing, 'Where the money goes for an AgentPad token, read live from Base', and enumerates the exact artifacts it returns (fee wallets, feeRecipient, owner, timelock, Sourcify links, unlock schedule, graduation liquidity). This clearly separates it from siblings like get_token, honest_volume, and agentpad_info, which cover narrower slices. It stops short of a single crisp verb+object statement such as 'Returns a token transparency report', so it is strong but not maximally sharp.

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

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

There is no explicit instruction on when to call this versus get_token, honest_volume, or agentpad_info, even though those siblings overlap on fields like volume and token metadata. The context ('due diligence on a token') is implied by the enumeration but never stated. An agent must infer routing from field lists alone.

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