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

Annotations already mark the tool as destructive and not idempotent. The description adds valuable context about the private key source (environment variable) and confirms that it submits onchain. No contradictions with 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?

Three concise sentences: one for core purpose, one for usage guidance, one for input context. No fluff, but the structure could be slightly improved by separating the 'DEV ONLY' emphasis more explicitly. Still efficient.

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

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

The description covers purpose, input context, and usage constraints. An output schema exists but is not shown; the description does not explain return values, but given the presence of an output schema, this is acceptable. Could mention potential errors or gas implications, but overall adequate for a dev-only tool.

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

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

Schema coverage is 100% with each parameter described. The description adds no parameter-specific information beyond the schema, only stating that the tool takes the transaction object from write.* tools, which is implicit from the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool signs and broadcasts unsinged transactions using a local private key, explicitly marking it as DEV ONLY. This disambiguates it from the sibling write.* tools (which generate transactions) and from production wallet servers mentioned as alternatives.

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 advises using this tool only in development and suggests alternative dedicated wallet MCP servers (Fireblocks, Safe, Turnkey) for production. It also specifies that the input is the transaction object from any write.* tool, providing clear when-to-use guidance.

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

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

Annotations already indicate safe, idempotent read. The description adds value by specifying that returned values are in human-readable USD and are net values, providing behavioral context beyond the annotations.

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

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

The description is two sentences, front-loaded with purpose and output, and includes a concrete usage hint. Every sentence adds value 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 existence of an output schema, the description adequately covers purpose, parameters, and behavioral hints. It provides all needed context for a simple historical data retrieval tool.

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

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

Schema coverage is 100%, so the schema already describes all parameters. The description only implicitly references 'days' via 'over a period', adding no new meaning to the parameters.

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 action ('Get historical collateral and debt values'), the resource ('Arcadia account'), and the output format ('time series of snapshots'). It distinguishes from siblings like 'read.account.info' by focusing on historical values over time.

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 includes a use case ('Useful for charting account performance over a period'), which implicitly suggests when to use the tool. However, it does not explicitly mention when not to use it or compare against alternatives like 'read.account.pnl' or 'read.account.info'.

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

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

Beyond annotations (readOnly, idempotent, openWorld), the description adds substantial behavioral detail: the health factor formula, unit conversion rules (raw units vs _usd fields with 18 decimals), automation object structure, chain-specific protocol support, and handling of deprecated managers. This gives the agent a rich understanding of what to expect.

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 long but front-loaded with the main purpose and then systematically covers field semantics, unit conversions, automation details, and cross-references. Every sentence provides valuable information, though it could be slightly tightened; however, given the tool's complexity, the length is justified.

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?

Even with an output schema present, the description adds essential interpretive context: health factor meaning, unit decimal handling, automation object semantics, and protocol-chain compatibility. It also covers usage guidance and cross-references, making it fully complete for an agent to select and 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?

Schema coverage is 100% with both parameters already described (chain_id and account_address). The description adds no new parameter-level semantics but does provide chain-specific protocol context (e.g., Slipstream V2 Base-only) that indirectly aids parameter selection. Baseline 3 is appropriate since schema does the heavy lifting.

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 'Get full overview of an Arcadia account' and lists specific fields (health factor, collateral, debt, assets, liquidation price, automation status), making the purpose precise. This clearly distinguishes it from sibling read tools like read.account.history and read.account.pnl.

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 directs to alternatives: 'For the full decoded per-manager config use read.asset_manager.current' and 'To list all accounts for a wallet, use read.wallet.accounts.' It also references write.account.automations for disabling superseded managers, providing clear when-to-use and when-not-to context.

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

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

Annotations already mark it as read-only, non-destructive, idempotent, and open-world. The description adds value by explaining the meaning of negative cost_basis, units (USD vs raw tokens), and that returns are lifetime totals, which are not covered by annotations.

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

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

The description is a single dense paragraph with no filler. It front-loads the purpose and covers key details. While it could benefit from bullet points, it is concise and informative 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?

Given the presence of an output schema (not shown), the description need not fully detail return values. It adequately explains the structure of returned data (lifetime totals, cost_diff in USD, per-token fields in raw units) and units. For a read-only tool with good annotations, it is complete.

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

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

Schema description coverage is 100% for both parameters, including details for chain_id (enum values and default). The description does not add new information about parameters beyond what the schema provides, so baseline 3 applies.

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

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

The description clearly states the tool retrieves PnL and yield for an Arcadia account, specifying the returned data (lifetime totals, cost basis vs current value, etc.). It uses specific verbs and resources, and among sibling read tools, it uniquely focuses on PnL, making its purpose distinct.

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 does not explicitly compare to sibling tools or state when to use this tool over others like read.account.history or read.account.info. Usage context is implied by its specific output, but no explicit guidance on scenarios or exclusions is 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?

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds value by specifying the return fields (address, symbol, decimals, type) and the search filtering behavior, going beyond 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: first states main function and output, second provides usage guidance. No wasted words; front-loaded with purpose.

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 list tool with fully documented schema and annotations, the description is adequate. It mentions output fields and directs to alternative tool. Could mention pagination or ordering, but not critical given low complexity.

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

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

Schema description coverage is 100%, so baseline is 3. The description reiterates the search parameter's purpose but does not add new meaning beyond the schema's description for either 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 clearly states the tool lists supported collateral assets on Arcadia and mentions the return fields (address, symbol, decimals, type). It distinguishes from the sibling read.asset.prices by directing users there for USD prices.

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 guidance on using the search parameter to filter by symbol and explicitly directs users to read.asset.prices for USD prices. Lacks explicit 'when not to use' but offers a clear alternative.

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 adds behavioral details beyond annotations: read_ok indicates unreliable results, deprecated managers are listed separately, and reward token registration is mentioned. No contradiction with readOnlyHint or other 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?

Every sentence contributes value: purpose, return data, deprecated handling, and error semantics. The description is somewhat dense but appropriately sized for the tool's complexity.

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 description covers purpose, return values, edge cases, and remediation paths. With output schema present, this is complete for the tool's complexity.

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?

Since the schema covers both parameters (account_address, chain_id) with 100% coverage, the description adds no extra parameter semantics. Baseline of 3 applies.

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

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

The description clearly states the tool reads currently enabled asset managers with decoded on-chain configuration. It distinguishes from related tools by focusing on 'current' managers and providing detailed return contents.

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 provides actionable context for handling deprecated managers through related write tools, and explains the read_ok flag's meaning. However, it doesn't explicitly compare with read.asset_manager.intents, so it lacks explicit when-not-to-use guidance.

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

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

While annotations already indicate read-only, idempotent, and non-destructive behavior, the description adds valuable conditional behavior: it explains what happens when account_address or position_id are passed, including the return of compatibility rules for blocked intents. It also notes that position_id requires account_address. This goes beyond the annotations and gives the agent a clear model of the tool's 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 three sentences long and front-loads the primary purpose. Each sentence adds distinct value without redundancy: the first defines the core function, the second explains the optional enhancement, and the third clarifies the default behavior. There is no filler or unnecessary detail.

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 has three optional parameters and conditional behavior, the description fully covers the usage space and output expectations. It mentions the compatibility-rule detail and the catalog-only default. Since an output schema exists, return values are adequately documented elsewhere. The description does not need to mention return format or additional details, making it complete for the tool's complexity.

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 already provides 100% coverage with descriptions for all three parameters, so the baseline is 3. The description enriches the semantics by explaining the purpose of account_address (per-account availability with compatibility rules) and the effect of position_id (scope to one LP position). It also clarifies the default behavior when account_address is omitted, which adds meaning beyond the schema.

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

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

The description clearly states the tool's main function: 'List the automation intents Arcadia supports, with the parameters each one accepts.' It uses a specific verb ('list') and identifies a distinct resource (automation intents) that separates it from sibling tools focused on accounts, pools, assets, and strategies. The conditional variants (with account_address, position_id) further clarify the exact scope of the operation.

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 clear context for when to use different parameter combinations: without account_address it returns the catalog only, with account_address it shows per-account availability and compatibility rules, and with position_id it scopes to one LP position. It does not explicitly name alternative tools or exclusions, but the guidance is specific enough for an agent to decide correctly. Sibling tool names are available in context but not referenced in the description.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, indicating a safe, idempotent read operation. The description adds the return format (price map keyed by address) but no additional behavioral traits like rate limits or auth requirements.

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 sentence followed by a usage clarification. It is front-loaded, concise, and every word adds value. No unnecessary information.

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

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

Given the simple purpose, rich annotations, fully described parameters in schema, and presence of an output schema (not shown but signaled), the description sufficiently explains functionality, input format, and return structure for correct agent 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 coverage is 100%, with descriptions for both parameters. The description does not add any new meaning beyond what the schema provides. Baseline score of 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 'read.asset.prices' and title 'Get Asset Prices' clearly indicate the action and resource. The description states 'Get USD prices for one or more asset addresses' with specific verb and resource, distinguishing it from sibling tools like 'read.asset.list' or 'read.wallet.balances'.

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 instructs how to pass addresses ('single or comma-separated'), implying usage for price lookups. However, it lacks explicit guidance on when to use vs. alternatives or when not to use it (e.g., for historical prices). The context from sibling tools partially fills this gap.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds usage context but not deeper behavioral details (e.g., pagination, response shape) — though an output schema exists, so the burden is reduced. It does not contradict the annotations.

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

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

The description is three sentences, front-loaded with the core purpose, and efficiently packs in usage timing and topic enumeration. No fluff or redundant phrases; every sentence 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?

Given the tool's simplicity (one optional parameter, full schema coverage, output schema present, and strong annotations), the description provides sufficient context: it explains the tool's role as a pre-workflow guide, when to invoke it, and what topics are available. There are no significant 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 100%: the only parameter 'topic' has a detailed enum description in the schema. The tool description largely repeats the same topic breakdown (overview, automation, strategies, selection) without adding much semantic value beyond what the schema already provides. The baseline of 3 applies because the schema does the heavy lifting.

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's purpose with a specific verb and resource: 'Get Arcadia workflow guides and reference documentation.' It distinguishes itself from sibling data-reading tools by positioning itself as a documentation/reference resource, and it enumerates concrete topics (overview, automation, strategies, selection) that clarify its scope.

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 usage context: 'Call this before multi-step workflows ... or when you need contract addresses, asset manager addresses, or strategy parameters.' This gives clear guidance on when to use the tool, though it does not explicitly mention when not to use it or name alternative tools, stopping short of a 5.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint, covering safety and side effects. The description adds the pagination behavior (offset/limit) beyond 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 with no redundancy: the first states purpose and pagination, the second provides the alternative. Front-loaded and efficient.

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

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

Given rich annotations, complete schema documentation, and an output schema, the description covers all necessary context: purpose, pagination, and alternative tool reference.

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

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

Schema coverage is 100% with detailed parameter descriptions. The description reinforces pagination context by explicitly mentioning 'paginated', adding slight value over schema alone.

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 'Get the Arcadia points leaderboard (paginated)' with a specific verb and resource, and explicitly distinguishes from the sibling tool 'read.wallet.points' for wallet-specific queries.

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 directs agents to use 'read.wallet.points' for individual wallet balances, providing clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, openWorldHint. Description adds context about APY history but no additional behavioral disclosures beyond that.

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 main purpose, no wasted words. Highly concise and structured.

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?

Description is sufficient given the presence of output schema. It covers purpose, usage, and relationship to siblings.

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

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

Schema description coverage is 100%, so description does not need to add parameter info. The description mentions APY history but does not elaborate on parameters beyond 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?

Description clearly states the tool gets detailed info for a single lending pool including APY history. It distinguishes from sibling read.pool.list which discovers pool addresses.

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

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

Explicitly states when to use (analyzing rate trends, comparing pools) and provides alternative (use read.pool.list to discover pool addresses).

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

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

Annotations already declare readOnlyHint, destructiveHint, and idempotentHint. The description adds that it lists all pools with no filtering, and explains decimal fraction output. No contradictions; adds useful behavioral context beyond 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 purpose and key fields, no redundant information. Every sentence adds value.

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 presence of an output schema and simple parameter, the description covers purpose, key field semantics, decimal format, and sibling reference. No gaps for a list tool.

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

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

Schema description coverage is 100% for the single parameter chain_id, including chain IDs and default. The description adds no further parameter information, which is acceptable per guidelines (baseline 3).

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

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

The description clearly states 'List all Arcadia lending pools' with specific fields (TVL, utilization, available liquidity). It distinguishes from sibling read.pool.info by directing users to that tool for APY history.

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 provides when-to-use (list all pools) and when-not-to-use (for APY history on a specific pool, use read.pool.info). This is a clear alternative and exclusion.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, openWorldHint, covering safety and idempotency. Description adds valuable context about APY values being decimal fractions, which aids correct interpretation of output.

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 concise sentences cover purpose, contents, usage tip, and important decimal clarification. No extraneous text; front-loaded with essential information.

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

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

Given the presence of an output schema, the description sufficiently covers purpose, input semantics, and a key output detail (decimal format). It also connects to the sibling tool for ID discovery, making it complete for an agent to use 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 description coverage is 100%; both parameters have adequate descriptions. The tool description reinforces strategy_id but adds no new semantic information beyond the schema.

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

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

The description clearly states the tool retrieves full details for a specific LP strategy by ID, listing included elements (APY per range width, pool info, configuration). It differentiates from sibling read.strategy.list by noting that tool is for discovering IDs.

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 instructs to use read.strategy.list to discover strategy IDs, providing clear guidance on prerequisite and sibling tool usage.

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?

Adds beyond annotations: paginated list, 7d avg APY per default range, APY decimal fractions. No contradiction with readOnlyHint etc.

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 efficient sentences, front-loaded purpose, no redundancy. Every sentence adds information.

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

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

Complete for a listing tool with output schema: covers pagination, APY format, and sibling for deeper 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 coverage 100%. Description adds value: recommends featured_only, explains pagination with limit/offset. Chain_id not elaborated but schema sufficient.

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' + resource 'Arcadia LP strategies'. Distinguishes from sibling 'read.strategy.info' which provides full detail on a specific strategy.

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

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

Explicit guidance: 'Use featured_only=true for curated top strategies (recommended first call)' and pagination instructions. Implicit when-not by directing to sibling for details.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. Description adds behavioral context: uses 1d APY, output format details. No contradictions, and the description complements annotations well.

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 concise sentences, each adding value: purpose, usage distinction, and output format hints. 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?

Given the existence of an output schema, the description adequately covers return value hints (APY decimal, USD unit). Distinguishes from sibling and provides enough context for a simple two-parameter tool.

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

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

Input schema has 100% coverage with clear descriptions for both parameters (account_address, chain_id). Description does not add new meaning beyond what schema provides, so 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?

Clearly states it gets a rebalancing recommendation for an Arcadia account, suggesting asset changes to optimize yield. Distinguishes from sibling read.strategy.list by specifying different APY period (1d vs 7d).

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

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

Explicitly says when to use this tool vs read.strategy.list, explaining that recommended strategies may differ due to APY basis. Also provides format hints for output values (APY decimal, USD).

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

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

Annotations already declare it as read-only, non-destructive, idempotent, and open-world. The description adds context about return format and the pattern to get full details, which is valuable beyond the annotations.

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

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

Two concise sentences. First sentence states the core function, second provides usage guidance. No extraneous info.

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 annotations and output schema present, the description covers purpose, return type, and links to a more detailed tool. It is complete for the agent to select and 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?

Input schema has 100% coverage with clear descriptions for both parameters. The description doesn't add significant meaning beyond schema, so baseline 3 is appropriate.

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

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

The description clearly states it lists accounts owned by a wallet address and returns a summary (address, name). It distinguishes from read.account.info by indicating that tool provides full details.

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 tells when to use this tool (for summary) and when to use read.account.info (for full details). No exclusions but clear context.

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

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

Annotations already declare readOnlyHint=true, so the description's 'Check' aligns but doesn't add behavioral insight beyond what annotations provide. No contradiction, but no extra context like rate limits or 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?

Two sentences, front-loaded with purpose and actionable guidance. 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?

Given the existence of output schema, high parameter coverage, and annotations, the description is sufficient. It covers the essential use case and relationship to a sibling tool, leaving no gaps for 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 coverage is 100% with parameter descriptions. The description does not add additional meaning beyond the schema; it only mentions 'spender address' generically, not enhancing parameter understanding.

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 ERC20 token allowances for a spender address, which is a specific verb and resource. It distinguishes from sibling read tools like read.wallet.balances by focusing on allowances.

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 instructs to use this tool before write.wallet.approve to avoid redundant approvals, providing a clear when-to-use scenario and naming the alternative tool.

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

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

Annotations already indicate read-only, non-destructive, idempotent, and open-world behavior. The description adds value by explaining the on-chain RPC multicall method and the dual return format (raw and human-readable), which are not captured by annotations.

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

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

The description is two sentences long, front-loaded with the main action, and every sentence provides 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 presence of an output schema (not shown but indicated), the description sufficiently explains the return values. It could include more detail on edge cases or errors, but overall it is adequate for the tool's complexity.

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 100% description coverage for all three parameters, so the description adds minimal extra semantics. It does mention the return format but does not elaborate on parameter constraints beyond the schema.

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

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

The description clearly states it retrieves native ETH and ERC20 token balances for a wallet, with a specific method (RPC multicall). This distinguishes it from sibling tools like read.wallet.accounts or read.wallet.allowances.

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 recommends using this tool before write.account.add_liquidity or write.account.deposit to verify sufficient tokens. This provides clear context, though it does not include explicit when-not-to-use scenarios.

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

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

Annotations already provide readOnlyHint, destructiveHint, idempotentHint, openWorldHint. Description adds no behavioral traits beyond the resource specifics, so minimal added value.

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, front-loaded with verb and resource, 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?

For a simple read tool with one required parameter and an output schema (assumed to document return values), the description is complete and sufficient.

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% for the single parameter. Description does not add any meaning beyond what the schema property description already provides.

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 action 'Get' and resource 'Arcadia points balance for a specific wallet address'. Distinguishes from sibling 'read.point_leaderboard' which likely returns leaderboard 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?

No guidance on when to use this tool versus alternatives like 'read.point_leaderboard'. Description only states what it does, not 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 time-sensitive calldata (30 sec), retry logic on revert, tenderly simulation URLs, expected_value_change format, and full context on capital sources. Adds significant behavioral context beyond annotations like idempotentHint.

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 detailed but efficiently structured with a clear lead and inline explanations. Some redundancy could be trimmed, but overall it earns its length by covering essential operational details.

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 (8 parameters, multi-step, time-sensitive, leverage options), the description covers all necessary aspects: capital sources, return fields, error handling, retry, and validation. With an output schema present, it explains return fields like tenderly_sim_url and expected_value_change comprehensively.

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

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

Schema coverage is 100%, so baseline 3. Description adds value by explaining capital sources (deposits vs account assets), tick optionality, and leverage semantics. Provides context like 'Omit to use only account collateral' and 'Margin accounts only' for leverage.

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 it is a 'multi-step flash-action' that atomically combines deposit, swap, mint LP, and borrow in one transaction. It explicitly distinguishes from siblings by saying 'Do NOT call write.account.deposit separately.'

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 explicit when-to-use guidance: capital sources, allowances, approval steps. Advises to call read.guides('strategies') for workflows. Clearly states when not to use alternatives like deposit.

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?

Adds substantial behavioral context beyond annotations: save mode disables omitted intents, preview mode returns no transaction, errors are never written on-chain, and no transaction is produced for no_changes_needed, simulated reverts, or preview_only. No contradiction with annotations; the diff-based save mode supports the idempotentHint.

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?

Long but tightly organized with an overview, mode explanation, bulleted intent definitions, and numbered backend rules. It is front-loaded with the core action and uses headers/bullets so an agent can scan efficiently without redundant prose.

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?

Covers workflow, error handling, return-value cases, prerequisites, and alternatives despite the rich output schema. It includes all needed context to invoke correctly, including the recommendation to call read.asset_manager.intents before 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?

Even though the schema covers 100% of parameters, the description enriches key parameters: mode's save-vs-preview consequences, position_id's backend auto-fill, intent-kind semantics, and the compatibility rules governing tokens/convert_tokens/destination. This far exceeds the baseline 3 for high schema coverage.

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

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

The first sentence states a specific action ('Configure an account's automations ... return the unsigned setAssetManagers transaction') with a clear resource and outcome. It also distinguishes itself from the sibling tool write.account.automations_delta by explicitly naming it for single toggles.

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 explicit when-to-use guidance: 'save' for a signable state, 'preview' for validation/planning, and write.account.automations_delta as the alternative for toggling one automation. It also instructs the agent to call read.asset_manager.intents first and explains when no transaction is returned.

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

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

Beyond annotations, the description discloses key behaviors: it returns an unsigned transaction (not an on-chain execution), disable entries with enabled:false are rejected, superseded/unreadable managers are force-disabled in the same transaction, and validated rules are returned as errors never written on-chain. It also discloses implicit CowSwap swaps for reward tokens. This far exceeds the minimal readOnly/destructive/idempotent flags in the annotations.

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

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

The description is long but well-structured: core purpose first, then enable/disable mechanics, then per-intent bullet summaries, then position_id guidance, then backend-enforced rules. It is appropriately sized for a complex tool, though a few points are duplicated (e.g., 'claim_merkl needs no position context' appears twice) and the intent bullet summaries partially repeat schema descriptions. Overall it is readable and 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?

Given the tool's complexity, the output schema existing, and the rich input schema, the description is exceptionally complete. It covers transaction return type, error behavior, how to disable, force-disabling, the distinction between full-state and delta, all intent kinds, positional context handling, and hard backend rules. An agent has all necessary context to invoke the tool correctly without reading external documentation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful orientation beyond the schema: it clarifies that the enable array cannot turn anything off, that the disable array takes addresses from read.asset_manager.current, and that position_id is strongly preferred and auto-fetches protocol/token context. It also explains shared constraints like the 'pure as-earned rule' and the 'every yielding token must be assigned' rule. This adds value, though the schema already contains detailed per-field descriptions.

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: 'Apply an explicit change to an account's automations and return the unsigned setAssetManagers transaction.' It immediately distinguishes itself from the sibling write.account.automations by stating this is a delta, not a full desired state, and that unmentioned automations are left untouched. This clearly communicates both what the tool does and how it differs from similar tools.

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

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

The description gives explicit when-to-use guidance: 'Use it to switch one automation on or off without restating the others.' It also explains the alternative (write.account.automations) and describes the exact workflow for disabling, including calling read.asset_manager.current to fetch manager addresses. It further clarifies which inputs are rejected and how force-disabling works, giving the agent clear decision rules.

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

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

Annotations already indicate idempotent, non-destructive. Description adds that tool validates account type and rejects spot accounts, and requires positive free margin. No contradiction with 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?

Four efficient sentences: purpose, exclusion, requirement, precondition. No redundant 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 output schema present, description covers all necessary context: purpose, constraints, prerequisites, and validation behavior. No 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 100%. Description adds concrete pool addresses beyond schema, which aids selection. Amount 'in raw units' is already in 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?

Clearly states 'Build an unsigned transaction to borrow from an Arcadia lending pool against account collateral.' Distinguishes from sibling by noting it's not needed for leveraged LP, which uses write.account.add_liquidity internally.

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

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

Explicitly states when not to use (leveraged LP handled by add_liquidity), constraints (only margin accounts), and precondition (verify free margin via read.account.info).

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 atomic nature (3-step process), token remain after closing, time-sensitive calldata (30s), retry advice, and tenderly simulation. No contradiction with annotations; aligns with idempotentHint=true allowing retries.

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?

Well-structured with sections, bullet points, and clear instructions. Every sentence provides value; no redundancy. Efficiently communicates complex information.

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

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

Covers all aspects: purpose, modes, parameters, output (time-sensitive calldata, simulation), retry logic, and relationship to sibling tools. Complete given complexity and presence of output schema.

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% but description adds critical context beyond schema: explains asset parameter for LP vs ERC20, amounts, decimals, and when receive_assets is required. Provides practical usage tips.

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 'Atomic flash-action that closes an Arcadia account position in ONE transaction', specifying verb and resource. Distinguishes from sibling tools by advising to try this first before falling back to individual tools.

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

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

Explicitly tells when to use: 'ALWAYS try this tool first when closing/exiting a position.' Provides fallback strategy: 'Only fall back to individual tools if this tool fails.' Explains two modes and when to use each.

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

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

Annotations indicate idempotentHint=true and destructiveHint=false. The description confirms it builds an unsigned transaction (not executed), supporting idempotence. It also explains that creditor is ignored for V4 spot accounts. No contradictions with 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?

Three sentences front-loaded with purpose, then behavior details, then return value. No unnecessary words. Could be slightly more structured (e.g., bullet points) but is efficient and clear.

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 5 parameters and an output schema, the description covers the key behavioral aspects and version differences. It does not reiterate every parameter detail, but schema already covers those. The description is sufficient for an agent to choose and 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 100%, and the description adds significant context: it explains the meaning of account_version values and the role of creditor. This goes beyond the schema's basic descriptions, e.g., 'V3 margin account' vs 'V4 spot account'.

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 an unsigned transaction to create an Arcadia account via the Factory contract. It specifies the verb 'build' and the resource, and distinguishes between V3 margin and V4 spot accounts. The mention of deterministic address via CREATE2 adds clarity.

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 guidance on using account_version and explains when creditor is relevant vs ignored. It implies this tool is a prerequisite for other write.account operations but does not explicitly state alternatives or exclusions. Lacks an explicit 'when not to use' but is otherwise 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?

The description contradicts the annotations: annotations set idempotentHint=true, but the description states the returned calldata is time-sensitive and must be rebuilt if the transaction reverts, implying non-idempotence. Per scoring rules, a contradiction yields a score of 1.

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 front-loaded with the main purpose, followed by usage guidelines and behavioral caveats. It is structured logically, but slightly verbose with 7 sentences; could be more concise without losing value.

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?

Covers essential context: atomicity, alternatives, time-sensitivity, retry logic, and pre-broadcast validation. Given the tool's complexity and the presence of an output schema (mentioned in context signals), the description is sufficiently 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?

Input schema covers 100% of parameters with descriptions. The description adds minimal new meaning beyond the schema, such as 'no wallet tokens needed,' but the parameters are already well-documented. Baseline for high coverage is 3.

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

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

The description clearly states the tool's function: 'sells account collateral to the debt token and repays in one atomic transaction — no wallet tokens needed.' It distinguishes itself from sibling tools like write.account.repay and write.account.close.

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 tells when to use (standalone repayment while keeping position active) and when not to use (closing a position, which should use write.account.close, or repaying from wallet tokens, which should use write.account.repay). Provides clear alternatives.

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?

Description adds that the tool builds an unsigned transaction (not executed) and auto-detects account version on-chain, which aligns with annotations (idempotentHint=true) and provides context beyond them.

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?

Description is concise with two sentences, front-loading core purpose and including key details without redundancy. Slightly longer due to critical usage notes, but still efficient.

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

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

Given the presence of an output schema and comprehensive schema descriptions, the description covers necessary context: purpose, prerequisites, sibling relationships, and parameter nuances. Minor gaps like error handling are acceptable.

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

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

Schema coverage is 100% with detailed parameter descriptions. Description adds value by clarifying asset type support (ERC20, ERC721), emphasizing optionality of asset_types (V4 only, inference), and account_version auto-detection.

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?

Description clearly states it builds an unsigned transaction to deposit assets into an Arcadia account as collateral, specifying supported asset types (ERC20, ERC721) and distinguishing from similar tools like write.account.add_liquidity.

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

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

Explicitly states it is NOT needed before write.account.add_liquidity and provides prerequisite steps (check allowances, approve if needed), giving clear when-to-use and when-not-to-use guidance.

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

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

Annotations declare idempotentHint=true and openWorldHint=true. Description adds critical behavioral traits: time-sensitivity (30 seconds), retry recommendation, and tenderly simulation for pre-broadcast validation. No contradiction with 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?

Concise yet comprehensive. Uses bold for key terms, bullet points for retry steps, and front-loads the core purpose. Every sentence adds value.

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?

Fully covers the tool's role in the ecosystem (partial vs full exit), operational constraints (time-sensitive, retry), and validation hooks (tenderly). Output schema exists, so return values are handled there.

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 has 100% coverage. Description adds context beyond schema: explains adjustment must be less than total liquidity and references close for full removal, providing decision guidance that the schema alone 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?

Clearly states it's a flash-action to partially decrease liquidity from an LP position, and explicitly distinguishes from write.account.close which handles full exit. The verb 'remove_liquidity' is specific and resource is clearly LP position.

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

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

Explicitly says when to use this tool (partial decrease) and when to use write.account.close (full exit). Also provides retry guidance and time sensitivity, giving clear operational context.

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

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

Annotations already indicate idempotentHint=true and readOnlyHint=false. The description adds critical behavioral context: requires ERC20 allowance, implying an on-chain interaction that may fail without prior approval. It does not repeat annotation information, but adds value.

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 sentences, no fluff. The most critical information (purpose, alternative, prerequisites) is front-loaded. Every sentence 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?

Given the complexity of DeFi repayment, the description covers purpose, prerequisites, alternatives, and links to related tools for checking state. With an output schema present, return values need not be explained. The description is self-sufficient for correct agent 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 coverage is 100%, so the schema already documents each parameter thoroughly. The description adds no new parameter-level details but contextualizes the amount as 'raw units, or max_uint256' and provides example addresses for pool_address, which is helpful but not beyond baseline for high coverage.

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 'Repay debt to an Arcadia lending pool using tokens from the wallet', specifying the verb and resource. It directly distinguishes from the sibling tool write.account.deleverage by contrasting token repayment vs. collateral repayment.

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 tells when to use this tool (when wallet tokens are available) and when not to (use deleverage for collateral). It also provides prerequisite steps: check allowance with read.wallet.allowances, approve if needed with write.wallet.approve, and check outstanding debt with read.account.info.

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 key behaviors beyond annotations: atomic flash-action, time-sensitive calldata, potential revert due to price movement, retry recommendation, and Tenderly simulation unavailability. No contradiction with annotations (readOnlyHint=false, idempotentHint=true).

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 core purpose, each of four sentences adds unique value: operation types, parameter guidance, time-sensitivity, error handling. No redundant phrasing.

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?

Covers preconditions, error handling, parameter nuances, and environment specifics (simulation). With output schema present, description fully equips agent 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?

Adds significant meaning beyond schema: explains asset_address usage differs by action (non-staked vs staked PM address). Schema descriptions are generic; description clarifies operational logic for all parameters.

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 performs flash-actions: stake, unstake, or claim rewards for an LP position. This distinguishes it from sibling tools like write.account.add_liquidity or write.account.remove_liquidity.

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 explicit guidance on using the action parameter, specifying asset_address for staking vs unstaking, time-sensitivity (broadcast within 30s), retry logic, and a precondition (verify position existence). Lacks explicit when-not-to-use but sufficient.

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

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

Annotations provide idempotentHint and readOnlyHint; description adds time-sensitivity (30s), retry behavior, and Tenderly validation steps, exceeding annotation coverage without contradiction.

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

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

Front-loaded with core purpose followed by critical notes; slightly verbose but every sentence adds value. Could be slightly tighter but overall good structure.

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?

Covers all operational aspects: atomicity, route selection, time sensitivity, retry logic, and pre-broadcast validation. Complete for safe and effective use given the complexity.

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 has 100% coverage with descriptions for all 6 parameters; description adds minimal extra meaning (e.g., slippage unit already in schema), so baseline 3 applies.

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

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

The description clearly states it swaps assets within an Arcadia account atomically, and explicitly distinguishes it from the sibling tool write.account.close for position closing scenarios.

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 explicit when-to-use (standalone swaps) and when-not-to-use (when closing a position, prefer write.account.close), plus retry and pre-broadcast validation instructions.

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

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

Beyond annotations, description discloses revert conditions, unsupported max_uint256, and auto-detection of account version. Does not mention rate limits or side effects beyond reverts, but idempotentHint already indicates safety.

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

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

Four sentences, all essential, front-loaded with purpose, 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?

Given complexity and existence of output schema, description adequately covers behavioral constraints, prerequisites, and parameter guidance, making the tool fully usable.

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 covers all 7 parameters with descriptions (100% coverage). Description adds minor value by advising exact amounts from read.account.info, but does not significantly enhance parameter understanding beyond 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 clearly states the tool builds an unsigned transaction to withdraw assets from an Arcadia account to the owner's wallet, with a specific verb and resource, distinguishing it from other write.account.* 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?

Provides clear context: only owner can withdraw, reverts if undercollateralized, no max_uint256, and recommends using read.account.info for amounts. Does not explicitly list alternatives but purpose is distinct 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?

The description explicitly states the tool builds an *unsigned* transaction rather than executing it, which is a critical behavioral detail not captured by annotations. It also mentions the prerequisite approval, adding transparency beyond the structured fields.

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

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

Two succinct sentences with no wasted words. The key information is front-loaded: purpose in the first sentence, prerequisites and related tools immediately follow.

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 of a DeFi deposit transaction and the presence of an output schema, the description adequately covers what the tool does, prerequisites, and related tools. It could mention the output transaction object, but the output schema likely compensates.

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

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

Schema coverage is 100% with good descriptions. The description adds extra value: an example for 'assets' (e.g., '1000000' = 1 USDC) and typical usage for 'receiver' (the depositor's wallet). This goes beyond the schema.

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

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

The description clearly states the tool builds an unsigned deposit transaction into an Arcadia lending tranche (ERC-4626), specifying the action and target. It distinguishes from siblings like write.pool.redeem by focusing on deposit.

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 prerequisites (prior ERC-20 approval) and references write.wallet.approve for that step. It also suggests checking current yield via read.pool.list or read.pool.info. It does not explicitly exclude alternatives but offers clear usage context.

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

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

Annotations are neutral (no readOnly/destructive hints), so the description carries the burden. It discloses that the tool burns shares and returns underlying asset with accrued interest, and that the owner must be the shares holder. This adds meaningful behavioral context beyond the structured fields.

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

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

Three sentences with no filler. The first sentence states purpose, the second explains the effect, the third provides ownership requirements. Every sentence is essential and 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?

Given the tool builds an unsigned transaction and has an output schema, the description covers the primary purpose, key parameter relationships, and constraints (owner=holder, receiver destination). It does not detail the output format or signing steps, but the output schema likely fills that gap. Overall sufficiently complete for a transaction 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 coverage is 100%, so baseline is 3. The description adds value by providing usage hints: referencing read.pool.list for tranche_address, advising to use full share balance for redemption, and clarifying that receiver is typically the owner's wallet. This goes beyond the schema descriptions.

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 an unsigned redeem transaction for Arcadia lending tranche (ERC-4626), with specific verb 'build', resource 'unsigned redeem transaction', and context 'withdraw from Arcadia lending tranche'. It distinguishes from sibling tools like write.pool.deposit by mentioning redemption specifically.

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 clear context for use: it explains the roles of owner and receiver, and gives a hint to get tranche_address from read.pool.list. However, it does not explicitly state when not to use this tool or compare with alternatives like write.account.withdraw, so it misses some exclusion guidance.

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

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

The description discloses that the tool builds an unsigned transaction (no side effects), matches idempotentHint=true, and explains behavioral differences between token types. Annotations already confirm safe mutation (destructiveHint=false), and description adds context without contradiction.

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

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

Four sentences, each essential: core function, token-type differentiation, prerequisite usage, and a practical tip. No superfluous content; information is front-loaded and well-organized.

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 multi-token nature and prerequisite role, the description covers all key aspects: purpose, token behavior, required context (before deposit/add_liquidity), and a best-practice tip. Output schema exists, so return details are handled elsewhere.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by clarifying that amount is for ERC20 only and spender_address should be the Arcadia account address, enhancing parameter understanding.

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 unsigned approval transactions for tokens, specifying two cases (ERC20 approve, ERC721/ERC1155 setApprovalForAll). It also explicitly connects to its prerequisite role for other tools, distinguishing it from sibling write tools.

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

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

The description explicitly states when this tool is required (before write.account.deposit and add_liquidity) and advises checking allowances first via read.wallet.allowances, effectively communicating when to use and when to skip.

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