AgentPad

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 it checks the agent pass, returns unsigned calls rather than signing, produces an EIP-5792 wallet_sendCalls batch, and estimates about $0.01 gas on Base; but it omits permissions/auth needs, failure modes, slippage behavior, and whether it executes anything itself.

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 purpose is front-loaded and the ordered-call sequence is compactly expressed with arrows. The first sentence is dense but earns its place, and the short gas/disclaimer sentences are useful context.

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

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

For a six-parameter transaction-building tool with no annotations and no output schema, the description does explain the return shape and prerequisite ordering. It still leaves important gaps around referrer/slippagePct semantics and failure/error behavior, so it is adequate rather than 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 moderate at 67%, with wallet, eth, token, and agentId documented in the schema. The description mostly restates the default APBUILD and prerequisite flow, while referrer and slippagePct remain unexplained in both schema and description.

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

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

Starts with a concrete verb and resource: buy an AgentPad token on its bonding curve, defaulting to APBUILD, and says it returns ordered unsigned calls plus an EIP-5792 batch. The orchestration behavior is clear, but it does not explicitly distinguish itself from siblings like build_buy_tx, onboard_and_buy, or quote_buy.

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 implies when to use it (buying a token, including handling missing ERC-8004 identity or AgentPad pass) and gives a prerequisite sequence. However, it provides no explicit when-not guidance and does not compare against the many related buy/onboarding/build tools in the sibling list.

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 and does well: it states that nothing is signed (unsigned calls returned), that the steps are ordered and conditional ('ERC-8004 identity if missing -> AgentPad pass if missing -> launch'), that a wallet_sendCalls batch and cast script are produced, that the launch fee is 0 with gas around 0.00002 ETH, and that errors carry a `next` field. It stops short of stating required wallet permissions/network assumptions beyond 'Base'.

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

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

The core behavior (inputs, ordered return, cost, error hint) is front-loaded in one dense sentence, followed by a short tactical idea. The 'Idea:' sentence is promotional rather than invocation-critical, which keeps it from a 5, but overall there is little 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?

For an 11-parameter, multi-step, no-output-schema tool, the description supplies the missing return contract (ordered unsigned calls, EIP-5792 batch, cast script) and error-shape guidance, which is exactly what the absent output schema would otherwise need to convey. Minor gaps remain around optional parameter roles and preconditions such as whether the image is mandatory when no imageId is supplied.

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 64%, so the description should compensate for the undocumented remainder. It reinforces the three required inputs ('wallet, name, symbol and a picture') and implies agentId semantics via 'ERC-8004 identity if missing', but it says nothing about src, referrer, initialBuyEth, or the imageId vs imageUrl vs imageBase64 tradeoff, leaving those entirely to the schema.

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

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

The description opens with a specific verb and resource ('launch your token on AgentPad v2 (Base)') and then enumerates exactly what is returned: ordered unsigned calls (identity, pass, launch), an EIP-5792 batch, and a cast script. That composite 'ONE tool' framing distinguishes it from the granular sibling builders like build_launch_tx and build_register_erc8004_tx without needing to name them.

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

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

Usage is only implied: the 'ONE tool' phrasing and the list of staged calls suggest this is the all-in-one launch path rather than the step-by-step build_* siblings, but there is no explicit when-to-use or when-not-to-use statement. Nothing tells the agent when to prefer build_launch_tx or build_team_launch_tx instead.

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: unsigned (not submitted), launch fee 0, creator royalty 0.50% of curve trade volume, the default 5% roadmap vesting schedule, and the IMAGE_REQUIRED/IMAGE_INVALID failure codes. It omits who signs/broadcasts the returned tx and whether name/symbol must be unique on-chain.

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 version constraint, then economics, then the hard requirement; every clause carries information. It is dense – heavy parentheticals and an embedded vesting schedule – 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 an 8-parameter mutation/tx-building tool with no annotations and no output schema, the description covers versioning, economics, image requirement and default roadmap. Gaps remain on initialBuyEth behavior, name/symbol validation, and what the returned unsigned tx payload contains.

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 50% and the description compensates for the image parameters (imageUrl/imageBase64/imageId with upload_token_image) and metadata hosting defaults. It adds nothing about initialBuyEth beyond 'optional' – no units, format, or curve effect – and says nothing about name/symbol constraints despite symbol being capped at 16 chars.

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 one-call solo launch tx on AgentPad v2) and pins the launch target version. The word 'solo' implicitly separates it from build_team_launch_tx in the sibling list, so an agent can route between the two launch builders.

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 v2 is the ONLY launch target and that v1 launches are disabled on-chain (v1 tokens still trade), which prevents a wrong-version call. It routes to upload_token_image for the required picture but never states when to prefer build_team_launch_tx over this solo 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?

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 disclosure burden and does well: it states the transaction is unsigned, that the return payload may include approveTx (exact amount) and steps[] in order, and that tx is always the sell. It adds real sequencing guidance not available in structured fields. It does not mention the version-detection mechanics or what happens when the wallet is omitted beyond the implicit case.

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?

Dense, telegraphic, and front-loaded with the essential action; the conditional approveTx/steps[] caveat follows the main statement. Slightly compressed phrasing ('v1 or v2', 'on pads that sell with the ERC-20 allowance') costs a little readability 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 4-parameter transaction builder with no annotations and no output schema, the description explains enough of the return shape (approveTx, steps[], tx) to be actionable, but leaves slippagePct semantics and the token identifier undefined. Adequate rather than 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 only 25% (only wallet is documented in the schema), so the description must compensate. It does clarify that amount is a whole-token quantity, which is genuinely valuable, but slippagePct and token are never explained in the description or schema. Partial compensation for a real gap.

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

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

Specific verb and resource: builds an unsigned sell transaction for AgentPad tokens back to the curve, with a scope note (whole-token amount) and version coverage (v1 or v2). It does not name the closest sibling, build_sell_with_permit_tx, so the agent must infer the distinction, but the core purpose is unambiguous.

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

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

Usage is implied through the conditional behavior: pass a wallet to get an allowance check, and on v2.3+ pads the approveTx must be sent BEFORE tx. However, there is no explicit statement of when to pick this over build_sell_with_permit_tx or when to consult quote_sell first, so routing between 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?

Without annotations the description carries the burden, and it does disclose valuable behavior: the tx is unsigned, it is a single atomic transaction (no separate approve), and the permit is consumed by the sell (non-reusable). It omits failure modes, whether the permit must match exactly, and slippage behavior, so it adds context but not enough to fully substitute for 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?

Two sentences, front-loaded with 'Unsigned tx' and the version/token-type qualifier. There is minimal waste, and the permit-provenance detail is packed without 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 build-tx tool with no output schema, the description covers what it builds and the permit provenance, but it is silent on the shape of the returned unsigned tx, the default/handling of slippagePct, and any failure prerequisites, leaving gaps an agent might need to call it correctly.

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

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

Schema coverage is only 20% (deadline only), so the description should compensate more. It does clarify that `amount` should equal the permit's exact amount and that `signature` is the permit signature from build_sell_tx, adding real meaning, but `token` and especially `slippagePct` remain undocumented.

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 (build unsigned tx) plus resource (one-transaction sell via a Permit signature), and it identifies the source of the permit from build_sell_tx. It is clearly a permit-based variant of build_sell_tx, though it stops short of an explicit 'use this instead of build_sell_tx when X' statement.

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 useful conditions parentalhetically ('pad v2.3+, EIP-2612 tokens') and says the permit comes from build_sell_tx, which implies the prerequisite. But it never explicitly states when to choose this over the plain build_sell_tx two-step flow or what to do when a token lacks EIP-2612 support, leaving 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 behavioral burden and does well by stating this returns an unsigned transaction and should be sent from the lead wallet. It also discloses key prerequisites and constraint rules, but does not describe the returned transaction shape or any permission/auth behavior.

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

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

The description is dense but appropriately sized for an 11-parameter transaction builder, and the purpose and key constraints are front-loaded. Some all-caps emphasis and crammed parenthetical rules make it less clean than ideal.

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, 11-parameter builder with no output schema and no annotations, it covers the most important launch constraints and the unsigned-transaction behavior. However, it omits return-value semantics and leaves multiple parameters undocumented, so an agent still has to infer important details.

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 45%, so the description must compensate, and it does add important conditional constraints for team shares and milestone types. Still, it leaves several parameters such as metadataURI and initialBuyEth unexplained, so it only partially fills the gap.

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

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

The description names a specific operation: building an unsigned launch transaction on AgentPad v2 for a team token with a custom roadmap. It distinguishes the tool from a generic launch by emphasizing TEAM, up to 5 agents, and 1-5 milestones, though it does not explicitly name build_launch_tx as the solo 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?

It gives useful context such as 'AgentPad v2 is the ONLY launch target' and 'Send from the lead wallet,' plus the required token picture. However, it does not explicitly state when to choose this team-launch builder over sibling tools like build_launch_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 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 burden, and it does disclose the key behavioral trait: a generated fallback exists when no image is set, and version history is returned. It does not state that the operation is read-only, whether it fails for unknown tokens, or what format the image comes back in (URL vs bytes), which matters for an agent consuming the result.

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 no filler, and the primary payload (the picture and its fallback) is front-loaded. The parenthetical is well placed. Slightly overloaded with a field list in one breath.

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 does the useful work of enumerating the return fields, which is the biggest gap it could have filled. However, it leaves the sole input parameter's type and the image delivery format unresolved, so an agent still guesses on both ends of the call.

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 required parameter 'token' is undefined — the description never says whether it is a contract address, numeric ID, or symbol. With only one parameter the description could easily have resolved this ambiguity and did 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?

The description names a specific resource (an AgentPad token's image) and enumerates what is returned: current picture or generated fallback, IPFS CID, version history, creator, and metadata JSON URL. It is clearly a read of token imagery, distinguishable from mutation siblings like update_token_image. It does not explicitly contrast with get_token, which also likely exposes image-adjacent data.

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

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

There is no guidance on when to call this versus get_token, token_transparency, or agentpad_info, nor any prerequisites. The agent must infer that this is the image-specific lookup path. No exclusions or alternatives are 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?

With no annotations, the description carries the full burden and does well: it discloses the tool is read-only, queries balanceOf at the latest block (point-in-time, not historical), and operates on whole-token units. It omits error behavior for invalid wallet/token inputs, keeping it 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?

Three short sentences, front-loaded with the core question, then mechanism, then use case. Every sentence adds distinct value with no redundancy.

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

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

For a simple 3-param read tool with no output schema, the description covers purpose, mechanism, units, and a use case. The 'Does this...?' framing implies a yes/no result, making the return sufficiently clear, though it never explicitly states the response shape.

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 67% (wallet undocumented). The description adds meaning beyond the schema: token accepts 'any Base ERC-20' (not just AgentPad tokens), min is in 'whole tokens', and the use-case framing clarifies wallet as the payer/address being checked. This compensates well for the one undocumented 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?

States a specific question the tool answers ('does this wallet hold at least min whole tokens...right now'), names the mechanism (read-only balanceOf at latest block), and is clearly distinguishable from all the build_*_tx and token-info siblings. 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?

Provides a concrete when-to-use scenario: sellers granting holder perks should verify the payer address of an x402 payment before granting. It doesn't name an alternative to route away from (e.g., check_vote_eligibility), but there is no direct sibling competitor for balance checks, so the guidance is strong though not exhaustive.

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 it does disclose real behavior: data is read live from Base, the feeRecipient and owner are read from the contract, verification comes from Sourcify, and verdicts carry two-sided flags (MISMATCH, matches true/false, creator_traded not_traced, milestone hit/burned/pending with an 'n' on every verdict). It implicitly establishes a read-only call. It stops short of stating failure modes, RPC/rate-limit behavior, or what happens for an unknown symbol.

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 a single comma-spliced run-on that heaps a dozen clauses into one sentence, so nothing is front-loaded beyond the opening framing and scanning the capability list is hard work. Nearly every clause does carry distinct information, which keeps it out of the 1-2 range, but a bulleted or clause-separated structure would earn the content far more.

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 must encode the return surface, and it names most of it: creator/platform fee wallets, owner, timelock and scheduled upgrades, verification links, creator allocation unlock conditions, graduation liquidity/LP lock, volume, per-wallet net flows, block-pinned balance check, fee reconciliation, and milestone log. What is missing is the response shape (field names, nesting) and error/edge behavior for unknown or non-AgentPad tokens.

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% and the single 'token' parameter is documented as a symbol or 0x address, so the schema already does the work. The description adds nothing about the parameter itself (e.g., symbol-vs-address resolution or ambiguity), leaving baseline 3 appropriate for a one-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?

The opening clause 'Where the money goes for an AgentPad token, read live from Base' states a specific resource and read scope, and the enumeration that follows narrows it to fee routing, ownership, upgrades and liquidity. It is identifiable apart from get_token and list_tokens, though the overlap with the honest_volume sibling for volume data is never acknowledged.

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 statement of when to reach for this tool versus agentpad_info, get_token, or the dedicated honest_volume tool, even though it duplicates volume and net-flow content those siblings cover. The agent must infer from the ingredient list that this is the comprehensive transparency/due-diligence call.

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 so: creator-only authorization, signature scheme, replay protection via nonce+issuedAt, non-destructive behavior ('old versions are kept'), and an explicit custody assurance ('never touches keys'). This is exactly the behavioral context an agent needs before invoking a mutation.

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, then the step sequence, then the safety note. Dense but nearly every clause carries information; the arrow notation is compact and readable.

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 explains the key return value (the exact message to sign) and the overall flow. Minor gaps remain around token identifier format and error/validation behavior when the signature is invalid.

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

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

Schema coverage is only 43%, but the description compensates by grouping parameters into the two calls (token+image source, then imageId+nonce+issuedAt+signature) and explaining that the first call returns the message to sign. It could still clarify what 'token' accepts (address vs symbol), which neither source states.

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 ('change a token picture') plus a useful scope note that it works even after Uniswap graduation. It references the sibling upload_token_image only indirectly through the imageId parameter, so an agent must infer the division of labor rather than being told 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?

Explains the two-step flow clearly and names the precondition (only the creator wallet, via EIP-191 personal_sign). It does not explicitly say 'use upload_token_image first unless you have a URL/base64', leaving the choice of the alternative implicit.

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

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

With no annotations provided, the description carries the full behavioral burden and does so thoroughly: it discloses magic-byte validation, full decode, normalization to 512x512 PNG, metadata stripping, private-address blocking for URL fetches, and that the operation is free. These details go well beyond the input schema and give the agent confidence about processing and side effects.

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

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

The description is a single dense sentence with no wasted text. Important constraints and the downstream use are front-loaded, and 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 two-parameter upload tool with no annotations and no output schema, the description covers validation, normalization, rejection rules, return values, and downstream usage. An agent has enough information to call it correctly and understand what will happen to the uploaded image.

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 both imageUrl and imageBase64. The description adds meaningful constraints beyond the schema, such as accepted image formats, minimum dimensions, maximum size, and rejection behavior, though it does not explicitly map each constraint to a specific 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 verb and resource ('Upload a token picture') and adds precise scope: accepted formats, minimum dimensions, size limit, and rejection of SVG/HTML. It also names the downstream consumer ('pass to build_launch_tx'), making the tool's role clear relative to siblings like update_token_image and get_token_image.

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

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

The description gives clear usage context by explaining that the returned imageId and imageUrl are meant to be passed to build_launch_tx. It does not explicitly compare against alternatives such as update_token_image, but the intended workflow is clear enough for correct tool selection.

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