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

With no annotations provided, the description carries full burden. It discloses that the tool builds descriptors (not executing transactions) and that amounts are in raw units with decimal specifications. However, it does not mention any potential side effects, authorization needs, or error conditions, which are important for an agent deciding to call this tool.

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

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

The description is a single paragraph that packs significant information. It front-loads the main purpose and action distinctions. While concise, it could benefit from structure (e.g., bullet points for each action) to improve readability, but there is no wasted content.

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

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

Despite the tool's complexity (9 parameters, no output schema), the description does not explain the structure of the returned calls[] array, which is critical for an agent to use the results. It also leaves out explanation of the slippageBps parameter. For a tool with such complexity and no output schema, the description is incomplete.

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

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

The description explains parameters for each action: buy (token, amountUsdcIn), sell (token, tokensIn), create (name, symbol, metadataURI?, mode?). It adds meaning beyond the schema by specifying raw units and decimal precision for amountUsdcIn and tokensIn. However, it does not explain slippageBps or the full semantics of mode, and metadataURI is only mentioned as optional.

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 builds bonding-curve buy/sell or create-token descriptors, specifying three distinct actions (buy, sell, create) with their respective parameters. The verb 'build' and resource 'descriptors' are specific and distinguish it from sibling tools like arcade_swap which likely execute swaps.

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

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

The description provides explicit instructions on order of execution ('Run the returned calls[] in order (approve, then action)') and a requirement (token must be 0x address). However, it lacks explicit when-to-use or when-not-to-use guidance relative to sibling tools like arcade_swap or arcade_quote, though the action-specific parameter sets imply use cases.

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

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

The description accurately indicates a read-only listing operation. No annotations are provided, but the behavior is simple and fully disclosed.

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

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

Single sentence with no wasted words. Information is front-loaded.

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

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

For a zero-parameter, no-output-schema tool, the description fully explains what the tool does and what it returns.

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?

No parameters exist; schema coverage is 100%. Baseline 4 applies with no additional parameter info needed.

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

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

The description clearly states the tool lists always-tradeable reference tokens, with examples (USDC, stablecoins, BTC, ETH). It is distinct from sibling tools which focus on swapping, quoting, portfolio, trending, etc.

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

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

The description implies when to use (need reference tokens) but does not explicitly exclude alternatives. However, siblings' purposes are different enough that the usage context is clear.

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

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

With no annotations, the description carries the burden. It discloses that inputs are raw token units, tokenOut accepts symbol or address, and that the tool returns calls to be executed sequentially (approvals then swap). However, it omits details on error handling, gas costs, or slippage.

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 very concise (3 sentences) and front-loaded with the core purpose. Every sentence contributes essential information without 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?

Given the complexity (multi-input swap), no output schema, and no annotations, the description covers the main flow and parameter details. However, it lacks a clear specification of the return value structure (e.g., format of each call), which would help an agent parse the output.

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 description adds value: explains that inputs amounts are in raw token units, tokenOut can be a symbol or address, and implies minTotalOut is optional. This goes beyond mere parameter names.

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

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

The description clearly states the verb 'Build' and the resource 'basket-converge swap (Arcade aggregator)', specifying it converts many input tokens into one output token. This distinguishes it from siblings like arcade_swap (simple swap) and arcade_swap_finalize.

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

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

The description provides execution guidance ('Run the returned calls[] in order') but does not explicitly state when to use this tool versus alternatives. It implies usage for multi-input to single-output swaps but lacks explicit context or exclusions.

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

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

Discloses that only 'known-token' balances are returned, indicating a specific set of supported tokens. Lacks details on authentication, rate limits, or error conditions. With no annotations, this is adequate but not thorough.

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

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

One sentence with no fluff, front-loaded with key action. However, it could include more useful context without being verbose.

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?

Missing critical context: what constitutes a 'known-token', expected output format (e.g., list of balances), error handling, and network specificity. No output schema provided, so description should compensate.

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?

Does not clarify the format of the 'wallet' parameter (e.g., Ethereum address, Solana). Schema has no description coverage, so the description should add context but 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?

Clear verb 'Get' and resource 'known-token balances' with specific scope 'for a wallet address'. Distinct from sibling tools like arcade_swap and arcade_markets.

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

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

No explicit when-to-use or alternatives mentioned. Description implies usage for retrieving token balances, but no guidance on distinguishing from other arcade tools like arcade_markets.

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?

Discloses read-only nature and notes 'amountIn is in raw token units', but lacks annotations. Does not describe return format, rate limits, or behavior under failure conditions. With no annotations, the description carries the burden and could provide more.

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

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

Two sentences with essential information front-loaded. No wasted words.

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

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

With no output schema, 4 parameters, and no annotations, the description fails to explain what the tool returns, how to interpret slippageBps, or integration guidance. Incomplete for effective use.

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%. Description only clarifies 'amountIn' units. TokenIn and tokenOut (likely addresses or symbols) and slippageBps are unexplained, leaving critical semantics ambiguous.

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

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

Clearly states 'Best-execution price quote across all Arc venues' and 'Read-only', specifying the verb (quote) and resource (price across venues). Distinguishes from siblings like arcade_swap which likely executes swaps.

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

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

Implies usage for obtaining a quote before executing a swap, but does not explicitly state when to use vs alternatives like arcade_swap or arcade_swap_finalize. No exclusions or context 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 full burden. It discloses that the tool returns descriptors (not executing), specifies chain, recipient behavior, token unit handling, and required execution order. It does not explicitly state safety (read-only) but implies no mutation as it produces descriptors.

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 concise (4 sentences) with front-loaded purpose. Every sentence adds value: purpose, parameter specifics, execution order. No repetition or fluff.

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, the description partially covers output structure (mentions contractAddress, abiFunctionSignature, abiParameters) and execution order. It is missing details on slippageBps and error handling, but overall provides sufficient context for a developer to use the tool 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 0%, so description must compensate. It explains tokenIn/tokenOut accept symbols or addresses, amountIn is raw units with decimal note for USDC, and recipient is the agent wallet. It neglects to describe the optional slippageBps parameter, but the other four required parameters are well-addressed.

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 builds approve+swap contract-call descriptors for signing on ARC-TESTNET, with specific verb 'Build' and resource 'contract-call descriptors'. It distinctly distinguishes from sibling tools like arcade_swap_finalize by focusing on descriptor generation.

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

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

The description implies usage context (generating calls to be signed and executed in order) but lacks explicit guidance on when to use this tool vs alternatives like arcade_quote or arcade_swap_finalize. No exclusions or prerequisites 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?

No annotations are provided, so the description must disclose behavioral traits. It mentions 'get the execute() call' but does not clarify whether the tool actually executes a transaction or just returns call data. No mention of side effects, permissions, or safety for this likely write operation.

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

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

The description is two sentences, efficient and front-loaded. However, it relies on jargon like 'Permit2', 'typedData', and 'echoed permit' that may not be universally clear, slightly reducing accessibility.

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 7 parameters and no output schema, the description is too brief. It does not explain the return value, prerequisites (e.g., approvals), error conditions, or what 'echoed permit' entails. Significant gaps remain.

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

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

With 0% schema description coverage, the description should compensate but only names a few parameters ('same swap params', 'echoed permit', 'signature') without explaining formats, constraints, or relationships. The 'permit' parameter is mentioned but not defined.

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 is a second step in the Permit2 workflow, following arcade_swap. It specifies the action: inject the signature and get the execute() call, distinguishing it from the initial swap step.

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

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

The description explicitly indicates when to use: after signing the typedData from arcade_swap. It mentions passing the same swap params plus permit and signature, implying the sequence. However, it does not explicitly state alternatives or when not to use.

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 bears full burden for behavioral disclosure. It does not state that this is a read-only operation, nor does it mention potential rate limits, authorization needs, or what 'curve progress' entails. Important behavioral traits are omitted.

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

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

The description is a single concise sentence without unnecessary words. However, it lacks structure and could benefit from breaking out key details like parameters or output format. For a simple tool, it is adequate but not exemplary.

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

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

Given the tool's simplicity (one parameter, no output schema), the description provides only the basic purpose. It omits explanation of the output format, sorting order, and what 'curve progress' means, making it incomplete for an agent to fully understand usage.

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

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

The input schema has one optional parameter 'limit' with min/max but no description. The tool description does not mention this parameter at all, failing to add any meaning beyond the schema. With 0% schema description coverage, the description should compensate but 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?

The description clearly states the tool lists launchpad tokens ranked by market cap (USDC) and includes curve progress, which is specific and informative. However, it does not explicitly distinguish itself from sibling tools like arcade_launchpad or arcade_markets, though the focus on launchpad tokens and ranking by market cap suggests a unique purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives or any prerequisites. There is no mention of when not to use it or context such as required authentication or data freshness.

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