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

The description explicitly says 'Read-only: nothing is executed,' which reinforces the readOnlyHint=true and destructiveHint=false annotations. It also adds useful context beyond annotations by clarifying that this is a real-time estimate, not an execution, and by listing the returned components.

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 well-structured sentence followed by a clear read-only warning. It front-loads the core purpose and output details without wasting 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 an output schema present and annotations covering safety, the description provides the essential context: what is estimated, what the result contains, and that no order is executed. The three required parameters are sufficiently documented in the schema, so nothing critical is missing for an agent to invoke the tool correctly.

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

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

Schema description coverage is 67%, with pair and amount already described in the schema. The description adds the market-order context and the notion of 'size,' but it does not meaningfully explain the side parameter beyond the schema's enum, and it adds little over the existing parameter 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 names a specific verb ('Estimates'), a specific resource ('a market order on Ripio Trade'), and the key outputs ('unit price', 'gross value', 'taker fee', 'total'). This clearly distinguishes it from sibling tools like ripio_get_prices or ripio_list_open_orders.

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 — when you need to know what a market order would cost or return before executing — but it does not explicitly state when to prefer it over alternatives like ripio_get_prices or ripio_get_limits. No exclusions or when-not-to-use guidance is provided.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful context by mentioning the rules to relay before transfers, but it does not detail what those rules are or what the returned structure contains.

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

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

The description is two sentences with no waste. It front-loads the primary purpose and then cleanly distinguishes the alternative tool for crypto deposits.

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

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

For a zero-parameter read-only tool with an output schema and clear sibling differentiation, the description covers all essential context: what the tool returns, the relevant regions, the transfer-rule caveat, and the alternative for crypto deposits. 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?

The tool has zero parameters and the schema is empty, so the description has no parameter semantics to add. With 0 params, the baseline is 4, and the description correctly focuses on the tool's output rather than inputs.

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: the tool returns the account's Ripio bank-deposit accounts for fiat, including CVU and alias in Argentina and PIX in Brazil. It also differentiates from the crypto deposit sibling by explicitly saying crypto deposits use ripio_get_deposit_address instead.

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 guidance on when to use this tool: for fiat bank-deposit accounts, and explicitly routes crypto deposits to ripio_get_deposit_address. It also implies this should be used before transfers, since it includes the rules to relay.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds specific behavior: it returns no address and lists receiving networks when network is absent/ambiguous, and it never creates an address. It also mentions relaying warnings. This is valuable context beyond annotations, though it could elaborate on error handling for invalid assets.

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

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

The description is a single dense sentence that packs all key points: purpose, memo/tag, warnings, network ambiguity behavior, and the Ripio Trade distinction. It is front-loaded with the primary purpose and efficient, though slightly long and could be split for readability. No redundant fluff.

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

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

The tool has an output schema (present in context signals), so return values are covered there. The description covers the main behaviors: address retrieval, memo/tag when needed, warnings, network ambiguity resolution, and the distinction from Ripio Trade. It is complete for a tool with only two parameters and simple output, though error cases for invalid asset are not mentioned.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds nuance: asset is a ticker with examples (USDT, BTC, AAPLx) and network is flexible (code, name, token standard). It also clarifies that network is optional and the behavior when omitted, which is not fully explicit in the schema. This adds meaningful semantics beyond the schema.

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

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

The description clearly states the tool's purpose: to fetch a crypto deposit address for an asset on a network, including memo/tag and warnings. It differentiates from Ripio Trade and notes it never creates an address, distinguishing it from potential write operations. The verb 'get' and resource 'deposit address' are explicit, and the behavior on missing/ambiguous network is specified.

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 mentions that Ripio Trade uses different addresses, which implies this tool is for the Ripio app (Wallet) only. However, it does not explicitly compare with siblings like ripio_get_deposit_accounts or ripio_verify_deposit_address, nor does it state when to use this tool over alternatives. The behavior on missing network could hint at usage, but the guidance is not fully explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behaviorcel. The description adds useful behavioral context beyond annotations: remaining amounts, daily/monthly/annual caps, the account-wide limit, and operations/fees per rail. No contradiction with the annotations is present.

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

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

The description is a single, front-loaded sentence that leads with the core value and adds distinct details in sequence: rail types, account-wide limit, time periods, remaining amounts, and fees. There is no filler or repetition.

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 limits lookup with an output schema and only two optional enum parameters, the description covers the essential domain concepts: rails, operation types, periods, remaining capacities, and fees. The main gap is the lack of explicit parameter filter semantics, but the structured schema already conveys optionality, and the output schema covers return values.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It does enumerate the rail and operation type values in prose, but it never explicitly explains that rail and type are optional filters or how the account-wide limit relates to the rail parameter. This is partial but incomplete compensation for the schema's lack of descriptions.

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

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

The description opens with a clear, outcome-focused statement: 'How much the account can still deposit, withdraw or swap', and then names the exact resource: Ripio limits per rail, including bank, pix, crypto, ripio, and the account-wide limit. This distinguishes it from sibling tools about portfolios, orders, activity, transactions, prices, and trade estimates.

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 establishes the context for use: checking remaining limits, caps, and fees per rail. It does not explicitly name alternatives or exclusionary conditions, so it stops short of full when-to-use versus alternative guidance, though the sibling tools make the intended use fairly obvious.

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 and idempotent behavior, so the description adds valuable behavioral context beyond them: zero balances are hidden by default, the valuation uses Ripio app sell rates, and the result combines multiple balance categories into one list. No contradiction with annotations is present.

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 well-structured: the first sentence delivers the main purpose and scope, and the second sentence flags the one important conditional behavior. Every sentence adds necessary information 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?

Given the single optional parameter, the presence of an output schema, and comprehensive annotations, the description covers everything an agent needs to select and invoke this tool correctly: scope, included asset types, valuation basis, and zero-balance handling.

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 fully describes include_zero with its default and meaning. The tool description echoes the zero-balance behavior ('Zero balances are hidden unless include_zero is true') but adds no new parameter semantics beyond what the schema provides, so the high-coverage baseline of 3 applies.

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

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

The description uses a clear verb-resource framing: it explicitly states what the tool returns (the user's current holdings on Ripio) and enumerates the contents (Wallet fiat/crypto, memecoins, Ripio Trade balances, available/locked amounts, ARS/USD estimates). This makes it readily distinguishable from siblings like ripio_get_prices, list_activity, or get_limits.

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 context about the data returned, which implies it should be used when an agent needs a consolidated current holdings snapshot. However, it does not explicitly state when to use this tool over alternatives or mention sibling tools, so the usage guidance remains implied rather than explicit.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior, so the description need not repeat them. It adds useful conditional behavior ('when the pair exists') and specifies the exact price fields returned, going beyond the structured 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 single sentence packs in the resource, the two data domains, the spread, and the comparison purpose without redundancy. It is front-loaded with the core purpose and each clause earns its place.

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

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

The description fully explains what data is returned and under what condition, and an output schema exists to cover return structure. Annotations handle safety and idempotence, so nothing critical is missing for a simple read-only price tool.

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

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

Schema coverage is 100%, with assets and quote already fully documented. The description reinforces that assets are tickers and that availability depends on the pair, but does not add new parameter-level meaning 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 uses a specific verb-resource pair ('current prices') and enumerates exact data points (buy/sell rates, spread, trade book fields). It clearly distinguishes this from sibling tools like ripio_get_portfolio or ripio_list_open_orders by focusing solely on market pricing data.

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

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

The purpose implies it should be used when current prices are needed, and the phrase 'so app and exchange prices can be compared' describes intent but not explicit selection criteria. It does not name alternatives or state when not to use it, such as when estimating a trade versus checking live prices.

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, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds a useful conditional ('on-chain hash when there is one') and scopes the resource to wallet movements, but does not discuss not-found behavior or errors. This is adequate but not rich.

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

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

One compact sentence, front-loaded with the core purpose and field list; no filler. The parenthetical source guidance is placed right after the id reference, keeping related information together.

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 single well-documented parameter, rich annotations, and an output schema present, the description covers what an agent needs to select and invoke the tool. The only omitted details (error behavior) are not necessary given the read-only, idempotent annotations and output schema.

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

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

Schema coverage is 100% and the schema already describes id as a number or the string ripio_list_activity returns. The description adds the extra constraint that the id must come from entries with source 'wallet', which is meaningful beyond the schema. Baseline 3 is therefore raised slightly.

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 uses a specific verb ('Full detail') and names the exact resource ('one Wallet movement') plus a concrete field list (amounts, fee, rail, counterparty, status, on-chain hash). It also anchors the id source to ripio_list_activity with source 'wallet', distinguishing it from other Ripio tools. This is unambiguous and differentiated.

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 tells the agent where the id comes from ('from ripio_list_activity with source "wallet"'), which is the correct precursor call. It doesn't spell out when not to use it, but for a single-id fetch this is sufficient context. No misleading alternatives are mentioned.

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 signal readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior; the description adds meaningful operational detail: pagination mechanics, UTC date handling, source-specific from/to semantics, the 182-day trade range limit, ordering, and unsupported transaction types. This goes well beyond the annotations.

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

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

Three dense sentences with no filler. The first sentence conveys the core purpose and default, the second lists unavailable categories, and the third packs pagination and date semantics. 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 7 optional parameters, two distinct sources, pagination, and source-specific filtering behavior, the description covers all key operational caveats. The output schema exists, so the description does not need to document return values, and no essential preconditions or limitations are 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 adds value by explaining the default source, cursor reuse, source-specific from/to behavior, and type/source associations (trade only in trade, swap only in wallet). Rail and currency remain schema-only, but their descriptions are already clear.

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 scope: deposits, withdrawals and swaps for the default wallet source, or Ripio Trade statement entries for the trade source, returned newest first in one normalized shape. This clearly distinguishes it from sibling tools like ripio_get_transaction, which retrieves a single transaction.

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 establishes when to use this tool, including the default source, the alternate trade source, and pagination via next_cursor. It does not explicitly name alternative sibling tools for cases like retrieving a single transaction, so it stops short of a 5, but the context is unambiguous.

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-destructiveness. The description adds useful behavioral context: optional filtering by pair/side and the amount fields present in the response. It does not contradict the annotations, and pagination is already hinted by the cursor parameter.

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

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

A single sentence that front-loads the operation and includes only valuable details: resource, optional filters, and output fields. There is no filler or repetition of schema 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?

For a read-only, no-required-parameter list tool with an output schema and documented cursor, the description is nearly complete. The main gap is the lack of explicit guidance on when to choose this tool over siblings, but that is minor for correctly invoking it.

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 pair and cursor, and the side enum is self-explanatory. The description adds that filtering by pair or side is optional, which is helpful, but 'one pair or side' is slightly imprecise about whether both filters can be combined. With 67% schema coverage, the description partially compensates but does not fully add 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 states a specific action ('Open orders on Ripio Trade') and names the optional filters (pair, side) as well as the returned amounts (price, requested, executed, remaining). This clearly distinguishes it from sibling tools like list_activity, get_prices, or get_transaction.

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 phrase 'optionally for one pair or side' gives some usage context and clarifies that filtering is not mandatory. However, the description does not explicitly say when to prefer this tool over sibling alternatives such as ripio_list_activity or ripio_get_portfolio; the usage is implied rather than stated.

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

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

Annotations already mark the tool read-only, idempotent, and non-destructive, and the description adds rich behavioral context beyond that: exact character-by-character matching, memo/tag handling, network/asset compatibility, and mistyped-copy flagging. There is no contradiction with 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?

Three front-loaded sentences: core behavior, usage instruction, and negative scope. Every sentence earns its place, though 'with code' followed by 'character by character' is slightly redundant.

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

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

With annotations covering the safety profile and an output schema present, the description supplies everything needed to invoke correctly: exact-match behavior, memo handling, asset/network relevance, and the Ripio Trade exclusion. No critical context 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, but the description adds sender-perspective semantics beyond the schema fields: pass the address as pasted from where it will actually be used, and use the asset and network as the sender names them. This meaningfully sharpens how address, asset, and network should be supplied.

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 concrete verification action: it checks an address and optional memo/tag character-by-character against the account's Ripio Wallet deposit addresses and flags mistyped copies. It distinguishes this from sibling get/list tools and draws a clear scope boundary with 'Ripio Trade addresses are not checked.'

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 instructs when to use it: before someone sends to an address, passing the address exactly as pasted plus the asset and network the sender will use. It also gives an explicit when-not constraint for Ripio Trade addresses, though it does not name an alternative tool for that case.

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