Arcadia Finance

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

Annotations already indicate destructive and non-read-only behavior; the description adds valuable context by flagging DEV ONLY, mentioning the local private key env var, and clarifying this is the final onchain submission step. It does not go deeper into failure modes, but the annotation coverage plus dev-only warning cover the most important safety context.

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

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

Three focused sentences with no filler. The most important constraint (DEV ONLY) is front-loaded, the production alternative is stated, and the input source is clarified. 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?

With a rich schema, output schema, and annotations, the description covers what the tool does, when to use it, when not to use it, and where its inputs come from. Nothing essential for selecting or invoking the tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents to, data, value, and chain_id. The description points to the source of these values (a write.* tool result) but adds no parameter-level semantic detail beyond what the schema 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?

The description is explicit: sign and broadcast an unsigned transaction using a local private key. It names the resource (an unsigned transaction from write.* tools) and the action (submit onchain), and the DEV ONLY prefix clearly separates it from the read_/write_ sibling 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?

It states when to use the tool (after any write.* tool returns a transaction object) and explicitly warns against production use, naming alternatives (Fireblocks, Safe, Turnkey, etc.). This gives an agent clear routing 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, openWorldHint, idempotentHint, and non-destructive behavior. The description adds valuable interpretation: an empty history means no snapshots in the window, not a failure, and clarifies units for timestamp and net_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?

The description is compact and front-loaded: it states the purpose and return format in the first sentence, adds the use case, and closes with an important edge-case clarification. No wasted words.

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

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

With a complete schema, strong annotations, an output schema indicated, and a description covering return format, ordering, units, and failure semantics, the agent has everything needed to invoke this 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 description coverage is 100%, so the schema already documents all three parameters. The description adds return-value context but does not meaningfully enrich parameter semantics beyond what the schema 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?

The description clearly states a specific action ('Get an Arcadia account's historical net value over time') and resource, and details the return shape. It distinguishes itself from siblings like read_account_info and read_account_pnl by focusing on time-series 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?

It identifies a concrete use case: 'Useful for charting account performance over a period.' While it doesn't explicitly say when not to use it or name alternatives, the context is clear enough for an agent to select it appropriately among the sibling read tools.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive hints. The description goes far beyond that by explaining health factor semantics, automation object structure, deprecated managers, dex protocols, and exact unit conventions for numeric fields. There is no contradiction between the description and 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?

Purpose is front-loaded, but the description is a dense single paragraph with many tangential details, including instructions for write_account_automations, position_id, and deprecated manager cleanup. While most sentences carry useful information, the lack of sectioning and inclusion of write-tool guidance makes it less concise than it could be.

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

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

Even though an output schema exists, the description adds critical interpretation details: health factor scale, unit conversions, automation manager semantics, dex_protocol values across chains, and related tool routing. An agent has everything needed to call the tool correctly and interpret the returned data.

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 coverage is 100%, so baseline is 3. The description does not add meaningful parameter-specific guidance; account_address and chain_id are already described in the schema. The chain/protocol availability notes are useful context for interpreting data but not directly about parameter semantics.

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

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

The description opens with a specific verb and resource: 'Get full overview of an Arcadia account,' and enumerates concrete content areas (health factor, collateral, debt, assets, liquidation price, automation status). It also names sibling alternatives like read_asset_manager_current and read_wallet_accounts, distinguishing this tool from related ones.

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 the agent when to use alternatives: 'For the full decoded per-manager config use read_asset_manager_current' and 'To list all accounts for a wallet, use read_wallet_acounts.' It also gives context about when to use write_account_automations, which helps clarify boundaries around automation configuration.

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 communicate read-only, idempotent, non-destructive behavior, so the description correctly focuses on non-obvious output semantics: negative cost_basis means net profit withdrawn, and cost_basis/current_value/cost_diff are in USD while per-token fields are in raw units. This goes beyond annotations and prevents misinterpretation of return values.

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 core action and then provides compact, high-value details about return semantics and units. Every sentence earns its place, and there is no redundant or filler content.

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

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

Given the rich annotations, complete input schema, and presence of an output schema, the description covers everything needed for correct invocation: the lifetime scope, sign interpretation, and unit differences. No critical gaps are apparent.

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 documents both parameters, including chain_id's allowed values and default and account_address's meaning. The description adds no parameter-specific guidance, so with 100% schema coverage the 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 description opens with a specific verb and resource: 'Get PnL (cost basis) and yield earned for an Arcadia account.' This clearly distinguishes the tool from siblings like read_account_history or read_account_info, which serve different purposes even though they also target accounts.

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

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

The description makes the tool's context clear: it is for retrieving lifetime PnL and yield for an Arcadia account. It does not explicitly name alternatives or exclusion criteria, but the scope is specific enough that an agent can infer when this tool is appropriate.

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

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

Annotations already cover readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, lowering the bar. The description adds useful context about the compact return format and the asset fields included. 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?

Two efficient sentences with the core action and return format front-loaded, followed by the alternative tool pointer. Every sentence earns its place with no filler.

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

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

This is a simple read-only list tool with an output schema and fully documented optional parameters. The description covers purpose, filtering, return fields, and the price-related alternative, so nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%, so both search and chain_id are already documented. The description restates search filtering but adds no new meaning for chain_id; baseline 3 is appropriate when 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 states a specific verb ('List') and resource ('supported collateral assets on Arcadia'), plus the compact return fields (address, symbol, decimals, type). It explicitly distinguishes itself from read_asset_prices, so an agent can select the correct tool without opening schemas.

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

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

The description gives explicit usage guidance: 'Use search to filter by symbol substring' and 'For USD prices, use read_asset_prices.' This names the alternative and the condition that selects it, leaving nothing to inference.

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

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

Despite strong annotations (readOnlyHint, idempotentHint), the description adds meaningful behavioral details: read_ok=false means the result is unreliable rather than empty, and deprecated managers are listed separately. Also includes Merkl claim state and whether reward tokens need registering, going beyond annotation-provided safety traits.

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 serving a distinct role: purpose, output contents, deprecated handling, and error flag. No fluff, but slightly longer than minimal. The main purpose is front-loaded in the first sentence.

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?

An output schema exists, so the description does not need to explain return values fully, yet it covers key categories (active managers, intents, Merkl state) and the read_ok reliability flag. It also cross-references write tools for next steps. A minor gap: no explicit distinction from read_asset_manager_intents, which would improve completeness.

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 both parameters (chain_id, account_address) with descriptions already. The tool description adds no additional parameter-level meaning; it only uses 'account' contextually. 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 a specific verb and resource: 'Read which asset managers are currently enabled on an account, with their decoded on-chain configuration.' It lists concrete output fields and distinguishes itself from siblings by describing deprecated managers separately and naming the write tools used to clear them.

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

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

Provides explicit guidance for handling deprecated managers: 'pass their addresses to write_account_automations_delta to clear them, or run write_account_automations which disables them as part of the save.' This implies when to use the tool, though it does not explicitly contrast with read_asset_manager_intents.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: the difference between catalog-only and availability results, and that blocked intents come with a 'compatibility rule' explanation. This goes beyond the annotations without contradicting 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?

The description is three sentences, with the primary purpose front-loaded first, followed by conditional usage details. Every sentence provides necessary information without redundancy or filler.

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

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

With an output schema present and rich annotations, the description covers the core functionality and parameter variations. It explains the two modes (catalog vs. availability) and the role of position_id. It doesn't elaborate on what 'intents' are or chain_id behavior, but those are covered by output schema and input schema descriptions, making this fairly complete.

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

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

Schema coverage is 100% since all three parameters have descriptions. The description enhances this by explaining the effect of omitting parameters (e.g., 'Without account_address this returns the catalog only') and the dependency of position_id on account_address. This adds relational meaning not fully captured in the schema.

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

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

The description clearly states the tool's purpose: 'List the automation intents Arcadia supports, with the parameters each one accepts.' This uses a specific verb ('List') and resource ('automation intents') and distinguishes it from siblings like read_asset_manager_current by focusing on the catalog of supported intents rather than current settings.

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 conditional usage: 'Pass account_address to also get per-account availability... Pass position_id as well to scope availability to one LP position. Without account_address this returns the catalog only.' This explains when to use different parameter combinations, though it does not explicitly name alternative tools as 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavior details: it accepts multiple comma-separated addresses and returns a map keyed by address. However, it does not disclose potential edge cases, error behavior, or chain-specific behavior beyond what the schema already states.

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 concise sentences with no fluff. It front-loads the core purpose and then provides the key invocation detail (comma-separated addresses) and return shape. 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?

For a simple read-only lookup tool with full schema descriptions and output schema present, the description is largely complete. The only minor gap is that it doesn't explicitly explain how chain_id influences which chain's prices are returned, though the schema already documents the supported chain IDs.

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%; both chain_id and asset_addresses have descriptions in the input schema. The description mostly reiterates the schema's 'single address or comma-separated addresses' phrasing and adds little new semantic 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 verb ('Get'), the resource ('USD prices for asset addresses'), and the output ('price map keyed by address'). It distinguishes this tool from sibling tools like read_asset_list and read_pool_info by focusing specifically on price lookup for arbitrary 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?

The description implies when to use it—whenever USD prices for asset addresses are needed—but does not explicitly state when not to use it or mention alternatives among the many sibling tools. For example, there is no guidance distinguishing it from read_wallet_balances or read_asset_list.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, which the description neither contradicts nor repeats. The description adds useful behavioral context by specifying that the tool returns workflow guides and reference documentation across four topics, clarifying content scope and what the user can expect. It doesn't overpromise or hide side effects, and the output schema covers return-value details.

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 exactly two sentences: the first states the purpose and primary usage, and the second compactly lists the four topics with parenthetical summaries. It is front-loaded and every sentence earns its place; there is no fluff or 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 tool's simplicity (one optional parameter, strong annotations, and an output schema), the description is fully adequate. It covers what the tool does, when to use it, and what topics are available, while the schema and annotations handle parameter details and safety. No critical contextual gap remains.

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 a single optional parameter 'topic' with an enum and a description that already explains each allowed value (overview, automation, strategies, selection). The tool description repeats the same topic list with parenthetical explanations, but adds little beyond the schema's own descriptions. With 100% schema coverage, the baseline 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 'Get Arcadia workflow guides and reference documentation', combining a specific verb ('Get') with the resource ('workflow guides and reference documentation'). It distinguishes this tool from sibling read_* tools by being the only one focused on documentation/guides, and it enumerates the covered topics (overview, automation, strategies, selection).

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 says 'Call this before multi-step workflows' and gives concrete examples ('opening LP positions, enabling automation, closing positions') and use cases ('when you need contract addresses, asset manager addresses, or strategy parameters'). However, it doesn't name alternative tools or specify when not to use it, so it falls short of a perfect 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 the tool read-only, idempotent, and non-destructive. The description adds the pagination behavior, which is a key operational detail beyond annotations. This is sufficient contextual disclosure for a read operation with an output schema.

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

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

The description is two sentences with minimal waste: the first states the primary action, the second gives a clear alternative. It is front-loaded and easy to parse.

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

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

For a simple read-only leaderboard tool with schema-documented parameters and an output schema, the description covers the core purpose, pagination, and an alternative for a related use case. No additional context is necessary.

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 provides full descriptions for both limit and offset, including defaults and meanings. The description's mention of 'paginated' reinforces parameter usage but adds no new semantics beyond the schema, so a baseline score 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 gets the Arcadia points leaderboard, a specific resource. It also distinguishes itself from the sibling tool read_wallet_points by indicating that tool is for wallet-specific balances, eliminating ambiguity.

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 this tool (leaderboard) and when to use the alternative read_wallet_points for a specific wallet's balance. This provides clear differentiation and guides correct selection among sibling tools.

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

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

Annotations already cover read-only, idempotent, non-destructive behavior, so the description doesn't need to restate those. It adds behavioral context beyond annotations by specifying the APY-history scope and that it targets a single pool. No contradictions; the description is consistent with the read-only annotation.

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 earning its place: what it does, when it's useful, and which sibling to use for discovery. Front-loaded with the core action; no redundant or filler 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 tool's simplicity (one required param, output schema present, rich annotations), the description is complete. It covers purpose, use case, and sibling routing, while the output schema and parameter schemas supply the remaining invocation details. Nothing essential is missing.

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

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

Schema description coverage is 100%, with each parameter (days, chain_id, pool_address) already documented. The description does not add any parameter-level meaning beyond what the schema provides, so a baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Get detailed info for a single lending pool including APY history over time.' It clearly distinguishes this tool from siblings like read_pool_list (discover pool addresses) and write_pool_deposit/redeem (writes). The scope is explicit: one pool, not a list.

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

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

It gives concrete guidance on when to use the tool ('analyzing rate trends and comparing pools') and explicitly names the alternative for discovery: 'Use read_pool_list to discover pool addresses.' It doesn't state a formal when-not-to-use condition, but 'single lending pool' implies this is not for listing or multi-pool overviews.

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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful context beyond those annotations, particularly that all rates are decimal fractions (1.0 = 100%) and that the tool lists all pools, which helps the agent interpret results correctly.

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 wasted words. The first sentences state the core function, the second clarifies rate semantics and points to a sibling tool. 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?

For a tool with one optional parameter, a full output schema, and rich annotations, the description covers the essential behavioral nuance (decimal rates) and sibling differentiation. Nothing critical is missing.

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

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

Schema coverage for the single parameter is 100%, with chain_id fully documented including default and valid values. The description does not add any parameter-specific information beyond the schema, so the 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 description states a specific verb and resource ('List all Arcadia lending pools') and enumerates the key output fields (TVL, utilization, available liquidity). It also differentiates from the sibling read_pool_info by explicitly pointing there for APY history on a specific pool.

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 an explicit routing rule: for APY history on a specific pool, use read_pool_info. This tells the agent when to use this list tool versus the alternative, leaving no ambiguity about the boundary.

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, openWorldHint, idempotentHit, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: APY values are decimal fractions (with concrete examples) and the narrower-range-higher-APY tradeoff with rebalancing cost/risk. This enriches the agent's understanding of the returned data.

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, eachearning its place: the first identifies the tool and its main content, the second gives workflow guidance, and the third clarifies a critical numeric format detail. No fluff, and key information is front-loaded.

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

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

The tool has an output schema, so return structure is already specified, and annotations cover safety. The description completes the picture with strategy-detail content, sibling routing for discovery, and an essential APY format clarification. There is nothing missing that would prevent correct invocation.

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

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

Schema description coverage is 100% for both parameters, including chain_id descriptions and defaults, so the schema already documents parameters thoroughly. The description does not add parameter-level meaning beyond referencing strategy_id and chain context; per rubric, 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 uses a specific verb ('Get full detail') and resource ('LP strategy by ID'), and clearly distinguishes itself from list-type tools by emphasizing detail for a single strategy. It also names the sibling read_strategy_list as the discovery tool, making its scope unambiguous.

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

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

It states exactly when to use this tool (to get full detail of a specific LP strategy by ID) and explicitly directs the agent to read_strategy_list for discovering strategy IDs, which is a clear alternative. This provides actionable routing without requiring inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: the result is a paginated list, APY is for the strategy's default range, and APY values are decimal fractions rather than percentages.

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 with no filler: purpose, featured-only recommendation, pagination behavior, APY format, and sibling routing. The core purpose is front-loaded and 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?

For a read-only list tool with fully documented optional parameters and an output schema, the description covers everything needed to invoke it correctly: the resource, first-call recommendation, pagination, return-context, and the sibling for deeper detail. Nothing necessary is missing.

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

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

Schema coverage is 100% and every parameter already has a description and default, so the schema carries the parameter semantics. The description adds operational guidance like 'featured_only=true ... recommended first call' and pagination tips, but does not materially redefine any parameter's meaning.

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

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

States a specific action ('Get Arcadia LP strategies') and identifies the resource clearly. It also distinguishes itself from read_strategy_info by noting that the sibling provides full per-range detail, so an agent can correctly tell them apart.

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 recommends using featured_only=true for the first call and instructs the agent to increase limit or use offset for pagination. It also names read_strategy_info as the alternative when full APY-per-range detail is needed, making the when-to-use decision 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint as false, covering the safety profile. The description adds behavioral context beyond the annotations: it uses 1d APY rather than 7d, explains that APY values are decimal fractions, and notes that weekly_earning_difference is in USD. This helps the agent interpret outputs and understand why results may differ from the list ranking.

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 with no filler. The primary purpose is front-loaded, followed by a useful differentiation from a sibling tool, then essential unit clarifications. Every sentence contributes actionable 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?

The tool has a rich output schema, complete parameter schema, and annotations that cover mutability. The description adds the critical non-obvious facts about APY basis and unit conventions, so an agent has everything needed to select and invoke the tool correctly without confusion.

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 for parameters is 100%: both chain_id and account_address have descriptions in the input schema. The description does not add parameter-specific meaning beyond what the schema already provides, so the baseline of 3 applies. It does helpfully contextualize units and APY basis, but those are not parameter semantics.

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

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

The description states a specific verb and resource: "Get a rebalancing recommendation for an Arcadia account" and clarifies what it does — suggests asset changes to optimize yield. It also distinguishes itself from read_strategy_list by explicitly calling out the 1d vs 7d APY difference, so an agent can tell them apart.

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 this tool is relevant by contrasting its 1d APY basis with read_strategy_list's 7d APY. It implies that this tool should be used when a 1d-yield-based rebalancing recommendation is desired rather than the list ranking. It does not explicitly list exclusions or alternative tools, but the differentiation is strong enough for an agent to route correctly.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), and the description adds value beyond them by disclosing the return shape ('summary of each account (address, name)') and what is deliberately NOT returned (health factor, collateral, debt). This manages agent expectations about response richness. 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?

Three sentences with zero waste: the core action is front-loaded, the return shape follows, and the sibling routing closes it. Every sentence earns its place, and no information is duplicated from the schema or annotations.

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 simple read-only list tool: annotations carry the safety profile, an output schema exists so return values need no further explanation, and the description covers what the tool does, what it returns, and where to go for richer data. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, with both wallet_address ('Wallet address to list accounts for') and chain_id (with explicit chain IDs and default 8453) already documented. The description reinforces 'wallet address' but adds no parameter-level syntax or format detail beyond what the schema provides, so the baseline 3 is correct.

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

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

States a specific verb and resource: 'List all Arcadia accounts owned by a wallet address', and discloses the exact scope of what is returned ('summary of each account (address, name)'). It also differentiates itself from the sibling read_account_info, so an agent can distinguish them without opening either schema.

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

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

Explicitly names the alternative and the condition that selects it: 'Call read_account_info with a specific account_address for full details like health factor, collateral, and debt.' This tells the agent when to stop at this tool (summary needs) versus when to escalate (full detail needs), leaving nothing to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a useful workflow-level behavior (pre-approval check) but does not disclose additional behavioral traits such as output shape, pagination, or chain-specific behavior beyond what annotations and schema provide.

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 filler: the first states the core purpose, the second gives immediately actionable usage guidance. Every sentence earns its place and the most important information is front-loaded.

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

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

Given the strong input schema, clear annotations, and presence of an output schema, the description covers all necessary non-schema context: what is being checked, who the relevant parties are, and how the result should influence the follow-up approval action. No critical guidance is missing.

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

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

Schema description coverage is 100%, so the structured schema already documents all four parameters clearly. The description adds no substantial additional parameter semantics beyond reinforcing the role of spender_address and token_addresses in the allowance context.

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

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

The description states a specific verb and resource: 'Check ERC20 token allowances for a spender address.' It clearly distinguishes this tool from related siblings by focusing on allowance checks rather than balances or approval mutations, and it explicitly ties it to write_wallet_approve.

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 an explicit usage directive: use before write_wallet_approve and skip approving if the current allowance is sufficient. This names the relevant alternative tool and gives a concrete condition for when the read result should change the agent's behavior.

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, idempotentHint, and non-destructive behavior, so the bar is lower. The description adds useful context beyond annotations: data source ('reads directly from chain via RPC multicall') and return format ('raw balance in wei and formatted human-readable'). 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?

Three sentences, each with a distinct function: what it does, when to use it, and what it returns. The primary purpose is front-loaded and every sentence earns its place with no filler.

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

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

Combined with complete parameter descriptions, strong read-only annotations, and an output schema, the description covers the essential invocation context: purpose, preconditions, data source, and return format. Nothing critical is missing for correct selection and usage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces that token_addresses are ERC20 contract addresses and mentions raw vs formatted balances, but it adds no substantive parameter-level 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 opens with a specific verb and resource: 'Get native ETH and ERC20 token balances for a wallet address.' It clearly distinguishes this tool from the many read_account_* and read_asset_* siblings by focusing on wallet balances and explicitly mentioning the RPC multicall read mechanism.

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

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

It gives concrete, actionable guidance: use before write_account_add_liquidity or write_account_deposit to verify sufficient tokens. It does not explicitly compare against other read_* alternatives, but the stated use cases make selection unambiguous without 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?

Annotations already declare the tool read-only, idempotent, and non-destructive, so the description needs limited behavioral disclosure. It adds the resource context (Arcadia points) and the targeting of a specific wallet, but provides no additional behavioral details beyond what the annotations convey.

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, direct sentence that immediately conveys the function without wasted words or redundancy.

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

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

For a simple read-only tool with one parameter and an output schema present, the description provides sufficient context. It specifies the resource and target, and annotations cover safety, making the tool fully understandable.

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

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

The schema has full coverage for the single parameter (wallet_address) with a clear description. The main description adds no new parameter-level meaning beyond what the schema already states.

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

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

The description clearly states the action ('Get'), the specific resource ('Arcadia points balance'), and the scope ('for a specific wallet address'). This distinguishes it from sibling tools like read_point_leaderboard (which provides ranking data) and read_wallet_balances (which likely covers token 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 clearly implies the tool is for fetching points for a single wallet address. However, it does not explicitly mention when to prefer this over alternatives like read_point_leaderboard or read_wallet_balances, though the specificity is evident.

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 the annotations, the description discloses atomic single-transaction behavior, 30-second calldata time-sensitivity, retry-on-revert guidance, tenderly simulation response fields, expected_value_change units, and the before/after account value comparison. These are meaningful behavioral traits that annotations alone do not convey. No contradiction with the annotations found.

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 every sentence earns its place: purpose, exclusions, prerequisites, timing, failure handling, and response semantics are all covered. It is front-loaded with the core action and then layers operational detail in a logical order appropriate for a complex multi-step tool.

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 description covers all required operational context: when to use, prerequisites, account types, retry behavior, response fields, and value units. It even explains how to interpret expected_value_change and compare before/after account values, leaving no critical gap for an agent to call 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%, so the baseline is 3. The description adds cross-parameter meaning by explaining how 'deposits array' and 'use_account_assets=true' serve as alternative capital sources, that leverage applies only to margin accounts, and that omitting deposits means using only account collateral. This extra context lifts it above baseline.

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 'Multi-step flash-action' and enumerates exactly what the tool composes: deposit, collateral use, swap, LP mint, and optional borrow. It also explicitly distinguishes itself from write_account_deposit by warning 'Do NOT call write_account_deposit separately,' making its scope and role unmistakable.

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

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

It gives a concrete usage workflow: check read_wallet_allowances first, approve via write_wallet_approve if needed, then call with either deposits, account collateral, or both. It also clarifies margin vs spot account behavior, points to read_guides('strategies') for workflows, and instructs to retry at least once on price-related reverts.

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 critical behavioral traits beyond the annotations: in save mode the intents array is the complete desired state and omitted automations are disabled, preview mode returns no transaction, and no transaction is returned for no_changes_needed, simulation reverts, or preview_only. It also explains error handling and that compatibility violations are returned as errors rather than written on-chain. This aligns with the idempotentHint and non-destructive semantics.

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?

Although long, the description is dense and front-loaded: the core purpose and mode semantics appear first, then intents, then rules, then return behavior. Every section earns its place for a tool this complex, and the structure lets an agent quickly locate the most decision-relevant 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?

The description fully covers prerequisites (read_asset_manager_intents, position_id), mode differences, return fields (valid, errors, warnings, human_summary, plan, diff, transaction), cases with no transaction, and enforcement rules. With an output schema present, the description does not need to restate return shapes, and it still adds the edge-case behavior an agent must know to call the tool safely.

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 schema already documents parameters richly, so the baseline is 3. The description adds meaningful semantic context by explaining how the backend resolves asset managers, that position_id causes protocol, is_staked, token0, token1 and reward_tokens to be auto-filled, and that explicit values win. It also clarifies intent-kind behaviors and cross-intent compatibility rules, going beyond the schema's 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 states a specific verb and resource: 'Configure an account's automations from a list of intents and return the unsigned setAssetManagers transaction.' It also distinguishes itself from write_account_automations_delta and read_asset_manager_intents, making sibling differentiation clear even before reading the schema.

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

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

The description gives explicit when-to-use/when-not-to-use guidance: use 'preview' to validate and show a plan, use 'save' to get a signable transaction, and use write_account_automations_delta to toggle a single automation without restating the rest. It also instructs the agent to call read_asset_manager_intents first to discover which intents are available.

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 (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true) set the safety profile, and the description adds substantial behavior on top: the returned transaction is unsigned, superseded or unreadable managers are force-disabled in the same transaction, a backend rule violation is returned as an error and never writen on-chain, and position context is auto-filed with explicit values winning. Nothing contradicts the annotations; the delta semantics is consistent with 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 long, but the tool genuinely is complex (five intent kinds plus backend-enforced rules), and the structure helps: the first paragraph front-loads purpose and the delta-versus-full-state distinction, then enable/disable mechanics, intent semantics, position_id, and finally the rules section. It misses a 5 because several rules are restated in the schema's own field descriptions, creating mild redundancy.

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

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

For a high-complexity tool with an output schema and 100% parameter coverage, the description still carries everything an agent needs to invoke it correctly: the disable prerequisite (read_asset_manager_current), where position_id comes from (assets[] in read_account_info), the backend-enforced consistency rules, and the error-behavior contract. Nothing essential is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description then adds genuine meaning: it explains each intent kind's effect (e.g., claim_rewards mode as_earned versus convert_to and the convert_tokens subset rule), disambiguates the confusing enabled: false field by directing the agent to the disable array, and documents that position_id auto-fills protocol, is_staked, token0, token1, and reward_tokens. Some overlap with per-field schema text, but the added semantic value lifts it above baseline.

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

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

The opening sentence states a specific verb and resource ('Apply an explicit change to an account's automations') plus its return value (the unsigned transaction). It also names the sibling and the distinguishing feature: 'Unlike write_account_automations this is a delta, not a full desired state', so an agent can tell the two apart without opening either schema.

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

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

Explicit usage condition: 'Use it to switch one automation on or off without restating the others', with write_account_automations implied as the full-desired-state alternative. It also spells out the disable workflow and its prerequisite sibling: 'call read_asset_manager_current, take the address of the manager serving it, and pass that address in the disable array'.

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 clarifies that the tool only builds an unsigned transaction rather than executing a transfer, which is useful beyond the idempotentHint and destructiveHint annotations. It also discloses validation behavior for spot accounts and the free-margin requirement, adding meaningful operational context.

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

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

The description is well-structured and front-loaded with the core purpose. Each sentence adds value, covering the main use case, key exclusion, account-type constraint, and prerequisite verification, with only modest length relative to the behavioral nuance it conveys.

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

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

For a build-only transaction tool with a full input schema and output schema present, the description covers the critical operational context: when not to use it, account eligibility, validation behavior, and the needed pre-check. Nothing essential for correct tool selection or invocation appears to be missing.

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

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

Schema description coverage is 100%, so the input schema fully documents all parameters including the pool address constants, amount units, and chain_id options. The description adds domain context around account eligibility but does not need to repeat parameter details, so the baseline 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?

Description states a specific verb and resource: it builds an unsigned transaction to borrow from an Arcadia lending pool against account collateral. It also differentiates itself from write_account_add_liquidity, so an agent can distinguish it from a closely related sibling.

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 explains when the tool is NOT needed (leveraged LP via write_account_add_liquidity), which account types work (margin accounts) versus spot accounts that will be rejected, and even recommends a prerequisite check using read_account_info with a concrete condition: collateral_value must exceed used_margin.

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 significant behavioral context beyond annotations: the action is atomic, returned calldata is time-sensitive within 30 seconds, reverts should be retried by rebuilding, and tenderly_sim_url/tenderly_sim_status are provided for pre-broadcast validation. This goes well beyond the basic readOnly/destructive hints.

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

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

The description is well-structured with clear mode bullets and front-loaded atomicity, but it does include some redundancy, such as repeating that tokens remain in the account after closing. Still, every major detail serves a practical purpose and the organization aids comprehension.

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 description covers the action, the two modes, parameter nuances, failure recovery, time sensitivity, and follow-up withdraw guidance. The presence of an output schema makes further return-value explanation unnecessary, so nothing essential is missing for an agent to call this 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?

Although the schema already covers parameters at 100%, the description adds crucial semantics: LP positions must use amount='1' and decimals=1, asset_address refers to the position manager, ERC20 amounts use raw units, receive_assets is conditional on close_lp_only, and values should come from read.account.info. This materially improves correct invocation.

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 what the tool does: atomically closes an Arcadia account position by burning LP, swapping tokens, and repaying debt in one transaction. It also distinguishes itself from related write_account_* tools and explicitly names write_account_withdraw for transferring tokens out afterward.

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

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

Usage guidance is explicit and actionable: 'ALWAYS try this tool first when closing/exiting a position' and only fall back to individual tools if it fails. It also explains the two close_lp_only modes and when receive_assets is required, leaving no ambiguity about when this tool should be selected.

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?

It discloses that the tool only builds (does not send) a transaction, that the address is predicted deterministically via CREATE2, and how account_version/creditor change the resulting account type. These traits go well beyond the annotations, which only indicate idempotence and non-destructiveness.

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

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

The entire behavioral and semantic payload is delivered in two tight sentences with front-loaded purpose and no filler. Version/creditor rules are compressed into clear conditional clauses.

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 five parameters and an output schema, the description covers the core decision (version/creditor), the return behavior (predicted CREATE2 address), and the transaction nature (unsigned, to be signed/sent elsewhere). Nothing needed for correct invocation is missing.

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

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

Schema coverage is already 100%, so the baseline is 3. The description adds real algorithmic meaning beyond the schema by explaining account_version branching (3 → V3 margin; 0r 4 → V4 spot) and the creditor being ignored for V4, which directly affects how an agent fills 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 names a concrete operation—'Build an unsigned transaction to create a new Arcadia account via the Factory contract'—and the create-vs-modify frame separates it from every write_account_* sibling. The account-version semantics make the resource behavior unmistakable.

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 intended use is implicit in 'create a new account'—an agent can tell this is the account-creation step. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternative sibling is named, so it does not fully meet the 4-level bar for usage direction.

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 that the calldata is time-sensitive (30 seconds), that reverts should be retried at least once, and that tenderly_sim_url/tenderly_sim_status should gate broadcasting. These behaviors are not visible in annotations or schema and materially affect invocation.

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

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

The description is dense but every clause earns its place: core action, sibling alternatives, usage scope, time-sensitivity, retry policy, and simulation check. The most important identifying information is front-loaded.

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

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

For a multi-step flash action with time-sensitive calldata and pre-broadcast validation, the description covers decision-making, retry behavior, and safety checks. An output schema exists, so return-value details need not be restated; nothing essential is missing.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds narrative context but does not explain any parameter semantics beyond what the schema 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?

The description states a specific multi-step behavior: sell account collateral to the debt token and repay in one atomic transaction. It also distinguishes itself from write_account_repay and write_account_close, making the tool's scope unambiguous.

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

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

Usage guidance is explicit: use write_account_repay when repaying from wallet tokens, prefer write_account_close when closing a position, and use this tool only for standalone repayment while keeping the position active. This is a clear when/when-not statement.

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, so the description adds useful behavioral context beyond those hints: it builds an unsigned transaction rather than executing one, auto-detects account version on-chain, and supports an override. It does not contradict any annotation and gives enough behavior detail for safe invocation.

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 earning its place: the core purpose, asset support, a routing caveat about a sibling tool, the approval prerequisite, and version override behavior. There is no redundant or filler content, and the most important scoping information is front-loaded.

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

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

Given a 7-parameter tool with an output schema available, the description covers the key practical context: when the tool is unnecessary, what prior approvals are required, which asset types are supported, and how account version is resolved. The return format is already handled by the output schema, so no critical gap remains.

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

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

The schema already covers all 7 parameters with descriptions (100% coverage), so the baseline is 3. The main description adds semantic value by clarifying supported asset classes (ERC20 and ERC721 LP positions), explaining account version auto-detection with override, and tying the approval workflow to parameter requirements. This exceeds the baseline but is not dramatically more than the schema 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?

The description states a specific verb and resource: 'Build an unsigned transaction to deposit assets into an Arcadia account as collateral.' It also distinguishes itself from write_account_add_liquidity by explicitly explaining that the deposit tool is not needed before that sibling, making the tool's scope clear.

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 when-to-use guidance, including a direct exclusion: 'NOT needed before write_account_add_liquidity.' It also names the exact prerequisite workflow with alternatives: check read_wallet_allowances, then use write_wallet_approve if needed. This leaves no ambiguity about the proper calling sequence.

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 the annotations, the description adds meaningful behavioral context: the calldata is time-sensitive and must be broadcast within 30 seconds, failed transactions should be rebuilt and retried at least once, and the response includes tenderly_sim_url and tenderly_sim_status for pre-broadcast validation. These details materially change how an agent should execute the call. No contradiction with annotations detected.

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 core action, then moves to the key alternative, then to execution-critical guidance. Every sentence adds operational value, including the 30-second window, retry instruction, and tenderly simulation note. The length is justified by the tool's time-sensitive and failure-prone nature.

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 definition is complete for a transaction-builder tool: it covers what the tool does, when to use it vs. the sibling, the partial-exit behavior, time sensitivity, retry handling, and pre-broadcast validation. An output schema exists, so return-value details need not be restated, and the description adds the operational context an agent needs to call and act on the result 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%, so the schema already documents all five parameters in detail. The description reinforces the partial-vs-full distinction relevant to the adjustment parameter, but it does not add significant new parameter-level semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'PARTIALLY decreases liquidity from an LP position.' It also clarifies the resulting state ('position remains open with reduced liquidity; underlying tokens stay in the account') and explicitly contrasts itself with the full-exit sibling write_account_close, making the tool's identity unambiguous.

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

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

The description gives an explicit when-to-use signal: use this tool for partial removal, and for full position exit use write_account_close instead, noting that it 'batches everything into one atomic transaction.' This directly routes an agent to the correct sibling without leaving the decision to inference.

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

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

Annotations already establish that this is a non-read-only, non-destructive, idempotent write operation. The description adds useful behavioral context not in annotations: repayment consumes wallet tokens and requires an ERC20 allowance for the pool. It does not explicitly state that the tool builds a transaction, but the annotations and output schema mitigate that gap, and there is no contradiction.

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

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

Three purposeful sentences: the core operation, the closest alternative, and the required prerequisite checks. Every sentence earns its place and the primary action is front-loaded before routing and checklist 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?

For a 4-parameter write tool with a full output schema and existing annotations, the description covers the source of funds, prerequisite allowance/approval, debt checking, and the alternative collateral-based path. No critical operational context an agent needs to invoke the tool correctly appears to be missing.

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

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

Schema coverage is 100%, so the schema already documents amount in raw units or 'max_uint256', chain_id defaults, and pool address constants. The description adds that repayment is sourced from wallet tokens and that pool approval is required, but it does not materially deepen the meaning of individual parameters beyond what the schema 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?

Description opens with a specific verb-resource action: 'Repay debt to an Arcadia lending pool using tokens from the wallet' and immediately distinguishes itself from write_account_deleverage, which repays using account collateral instead. This clearly tells an agent what the tool does and how it differs from the closest sibling.

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 explicitly states when to use this tool versus the alternative: use write_account_deleverage when repaying with collateral and no wallet tokens. It also provides a concrete pre-flight checklist: check allowance with read_wallet_allowances, approve with write_wallet_approve if needed, and check 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?

Beyond annotations, the description discloses critical behavioral traits: the calldata is time-sensitive and must be signed and broadcast within 30 seconds, reverts should be retried at least once after rebuilding, Tenderly simulation may be unavailable, and the caller should verify the position exists via read_account_info before signing. These add substantial value beyond the readOnlyHint and idempotentHint 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 dense but each sentence earns its place: it defines the operation, explains a parameter nuance, warns about time sensitivity, gives a retry instruction, and advises a pre-sign verification. The most important framing, the atomic flash-action, is front-loaded.

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

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

For a complex transaction-building tool with five parameters, the description covers operation selection, address semantics, time sensitivity, failure handling, simulation limitations, and a pre-check prerequisite. Since an output schema exists, the description does not need to explain return values. This is complete enough for an agent to call 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?

Although schema coverage is 100%, the description adds essential semantics that the schema omits: asset_address must be the non-staked PM address when staking and the staked PM address when unstaking. It also clarifies the action parameter as the operation selector and ties asset_id to the LP position NFT, making parameter selection materially clearer.

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 action-verb construction: 'stake, unstake, or claim rewards for an LP position in one atomic transaction.' This clearly identifies the resource (LP position) and the operations, and 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?

The description gives clear operational context: use the action parameter to choose the operation, and choose the correct asset_address form depending on whether staking or unstaking. It does not explicitly name alternative tools or exclusion conditions, but the usage context is sufficiently clear for an agent to know when this tool applies.

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 a non-read, open-world, idempotent, non-destructive operation, but the description adds substantial behavioral context beyond those hints: atomicity, backend route selection, time-sensitive calldata, retry expectations, and tenderly simulation pre-broadcast validation. This is exactly the kind of operational behavior an agent needs to invoke the tool safely.

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 core action, then moves to critical usage caveats and safety instructions. Every sentence provides actionable information: atomicity, sibling tool preference, time sensitivity, retry policy, and tenderly validation. No filler or redundant restatement of the schema.

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

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

For a mutation tool with an output schema and rich annotations, the description covers all important context: when to use it, when not to, key behavioral caveats, retry behavior, and pre-broadcast validation. The output schema handles return-value details, so the description is complete enough for an agent to correctly select and safely invoke the 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%, so all six parameters are already documented in the input schema, including defaults and units. The description adds general context about swapping assets but does not need to repeat parameter-level details. It earns a baseline 3 because the schema carries the parameter semantics burden.

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: 'swaps assets within an Arcadia account in one atomic transaction.' It clearly differentiates from the sibling write_account_close by explaining when swap-only is intended versus when closing a position requires the batched tool. The resource, action, and scope are unambiguous.

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

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

The description explicitly says 'If you are closing a position (swap + repay + withdraw), prefer write_account_close' and 'Only use this tool for standalone swaps within an active position.' It also gives concrete operational guidance: broadcast within 30 seconds, retry at least once on revert, and do not broadcast if tenderly_sim_status is 'false'. An agent can determine exactly when to use this tool versus 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?

Beyond the annotations, the description discloses important behavioral traits: owner-only authorization, revert behavior under debt/undercollateralization, the max_uint256 limitation, and on-chain account version auto-detection. These add significant context that the annotations do not provide, and there is no contradiction with readOnlyHint=false or idempotentHint=true since it only builds an unsigned transaction.

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 four sentences with the core action front-loaded. Every sentence adds meaningful constraints or clarification: ownership, revert condition, amount limitation, and version override. There is no redundant or filler text.

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

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

Given the output schema exists and the input schema is fully documented, the description covers the critical operational details an agent needs: owner-only access, revert risk, exact amount requirement, and account version behavior. An agent has enough information to call this tool correctly without additional ambiguity.

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 covers all parameters with descriptions, so the baseline is strong. The description adds valuable parameter-level guidance: asset_amounts must be exact amounts from read_account_info and cannot be max_uint256, and account_version can override auto-detection. This goes beyond the schema's property 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 states a specific verb and resource: 'Build an unsigned transaction to withdraw assets from an Arcadia account to the owner's wallet.' This clearly distinguishes it from sibling write operations like deposit, borrow, or swap, and the phrase 'unsigned transaction' clarifies that it does not broadcast.

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 usage context: only the account owner can withdraw, withdrawal reverts if it would leave the account undercollateralized, and exact amounts must be passed rather than max_uint256. It does not explicitly name sibling alternatives or when not to use it, but the conditions and constraints are strong enough for an agent to select it appropriately.

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

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

The description clearly discloses that the tool builds an unsigned transaction rather than broadcasting it, and that prior token approval is required. It also explains the lender-facing behavior of receiving shares that accrue interest. These details go beyond the annotations, which only provide negative hints. No contradiction exists.

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 focused sentences with no filler. The first sentence states the core capability, the second explains the transaction mechanics, and the third covers prerequisites and related read tools. 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 rich input schema, the output schema, and the explicit prerequisite and related-tool references, the description provides everything needed to select and invoke the tool correctly. The 'unsigned' framing makes the follow-up broadcast step inferable, and no missing invocation-critical detail is apparent.

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 covers 100% of parameters with meaningful descriptions, including raw-unit examples for assets and how to obtain tranche_address. The description reinforces the context but does not add meaning beyond the schema, so the 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 description names a specific verb and resource: 'Build an unsigned deposit transaction into an Arcadia lending tranche (ERC-4626).' It further clarifies the economic mechanism—depositing the pool's underlying asset and receiving tranche shares—which distinguishes it clearly from siblings like write_pool_redeem or write_account_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 gives explicit context for usage: it states the prerequisite of prior ERC-20 approval and points to write_wallet_approve, and directs the user to read_pool_list or read_pool_info for yield information. It lacks an explicit 'use this instead of X' statement, which prevents 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?

The description discloses that the tool only builds an unsigned transaction rather than executing a withdrawal, which is core behavioral transparency beyond the default annotations. It further explains the effect of the built transaction, shares burned and underlying returned with interest, so an agent knows what the output represents.

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 with no fluff; the purpose is front-loaded and supporting role/behavior details follow. This is 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 plus the fully-covered schema and output schema cover all needed aspects: target tranche, share amount, owner/receiver roles, chain selection, and the unsigned nature of the result. Nothing required for correct invocation is left ambiguous.

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

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

With 100% schema description coverage, the baseline is 3 and no additional parameter documentation is required. The description's owner/receiver role notes are useful but largely repeat the schema descriptions, so it adds little param-specific meaning beyond 'including accrued interest.'

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 starts with a specific verb and resource: 'Build an unsigned redeem transaction to withdraw from an Arcadia lending tranche (ERC-4626)'. It also names the exact effect — burning shares and receiving the underlying asset with accrued interest — which makes it clearly distinct from pool deposit and account withdrawal 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?

The when-to-use context is clear: use this tool to withdraw from an Arcadia lending tranche by redeeming tranche shares. It also gives key role constraints, owner must be the shares holder and receiver gets the underlying asset, so an agent knows how to populate addresses. It does not explicitly rule out sibling tools, so it falls 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?

It discloses a critical behavioral trait: the tool builds an unsigned transaction, so it does not broadcast anything. It also explains what functions are generated for ERC20 vs ERC721/ERC1155, going beyond the annotations. The annotations already declared idempotentHint=true/destructiveHint=false, so the description doesn't need to restate those, but it could have explicitly said 'does not submit the transaction' for extra clarity.

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

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

The description is concise and front-loaded: purpose first, then dependency context, then an actionable tip. Every sentence earns its place, and there is no filler or unnecessary restatement of the input schema.

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

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

The description covers what the tool does, when it should be used, which sibling tool should be called first, and how different asset types are handled. Given the full input schema and output schema, an agent has everything needed to select and invoke this 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?

The schema already documents all five parameters at 100% coverage, so the baseline is 3. The description adds value by mapping asset_type to approve(spender, amount) vs setApprovalForAll(operator, true), and by explaining when amount is ignored. It mostly reinforces schema details rather than adding brand-new parameter semantics, so a 4 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 opening verb+resource 'Build an unsigned approval transaction' is specific and accurately captures the tool's purpose. It further distinguishes token-standard behavior (approve vs setApprovalForAll) and names the dependent write tools (write_account_deposit/write_account_add_liquidity), separating it from sibling account/pool operations.

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 states it is required before write_account_deposit or write_account_add_liquidity when depositing from wallet, and explicitly advises checking read_wallet_allowances first and skipping if the allowance is sufficient. This provides both a trigger condition and a clear alternative/precheck routing rule.

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