xrpl-referee

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

The description goes far beyond the annotations by detailing the fee payment options, single-use fee_hash anti-replay protection, the consensus behavior for require_consensus, and the exact return fields. This discloses significant behavioral traits (cost, side effects, conditional logic) that annotations only hint at via flags.

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 appropriately structured with a purpose statement, payment options, and return fields. It is somewhat lengthy but each section serves a purpose. The two payment options are slightly redundant (both can involve USDC on Base), which prevents a perfect score, but overall it is not bloated.

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 (fee payment, AI models, consensus option), the description covers the main aspects: purpose, precondition, return values, and a key optional feature. However, it omits error scenarios (e.g., invalid fee hash) and does not mention the task_category parameter, relying on the schema for that. Since an output schema exists, the return list adds minor redundancy.

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 does not add meaning to individual parameters beyond what the schema already provides. The payment procedure clarifies how to obtain a fee_hash but does not enrich parameter semantics; it's process guidance rather than parameter-level detail.

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

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

The description opens with a specific verb and object: 'Verify whether completed work meets a task specification using AI.' This clearly states the tool's function and distinguishes it from siblings like evaluate_escrow_work, which is escrow-specific. The resource is well-defined as completed work against a task specification.

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 for when to use this tool (to audit completed work) and includes a mandatory prerequisite (pay a fee before calling). However, it does not explicitly name alternatives or state when not to use this tool in favor of a sibling, 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?

The description adds significant behavioral context beyond annotations: it returns worker address and agreed price, automatically rejects other bids, and clarifies that no funds are held by the referee. This fully discloses side effects and data returned.

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 a purpose statement, workflow hint, and returns section. It is slightly longer than necessary but every sentence adds value. The inclusion of the returns block is helpful.

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 (3 parameters, simple action) and the presence of an output schema, the description fully covers the workflow, side effects, and next steps. No gaps are present.

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% with clear descriptions, the tool description adds context by referencing source functions (e.g., 'from view_job() bids list' for bid_id, 'from post_job()' for job_id), which helps the agent understand how to obtain these parameters.

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

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

The description clearly states it accepts a bid and awards the job to a worker agent, with a specific verb and resource. It distinguishes itself from sibling tools like 'direct_hire' and 'submit_bid' by focusing on accepting bids.

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 explains when to use the tool (to accept a bid) and provides a clear next step (create_escrow_vault). It mentions that other bids are automatically rejected, but does not explicitly list conditions when not to use it or compare with 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?

The description explains that the tool queries Xaman, caches the status, and unlocks escrows up to $10,000, which goes beyond the annotations' read-only and idempotent hints. It clearly states side effects (unlocking escrows) and idempotency (returns cached result). This is transparent, though a bit more on error conditions could be added.

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 structured in three sentences covering purpose, usage guidance, and return fields. It is concise and front-loaded with the main action. Each sentence contributes value, though the mention of 'registers' and 'unlocks escrows' could be seen as slightly tangential. Overall, it's tight and well-organized.

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

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

For a single-parameter tool, the description provides complete context: what it does, when to use it, side effects, idempotency, and the return fields. It also gives external context (Xaman, escrow limits) that an agent needs to use it correctly. No critical missing information.

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 only one parameter (wallet_address) and the description barely adds beyond the schema's 'r...' hint. Since schema coverage is 100%, the baseline score of 3 applies. The description does not clarify any parameter-specific nuances, so no additional credit.

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 the specific verb 'Check and register' with a clear resource (Xaman KYC status) and context (wallet operator). It explicitly distinguishes from siblings like check_wallet_sanctions by focusing on identity verification status. The description is highly specific and 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 provides clear guidance on when to call ('Call this after completing KYC in the Xaman app') and notes safety of repeated calls. However, it does not explicitly contrast with sibling tools like get_wallet_verification_challenge, though the context is sufficient for most agents to select 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 indicate read-only, idempotent, and non-destructive behavior. The description adds valuable transparency: data is cached for 24 hours, the tool always returns a result and never raises on list unavailability, and it describes consequences for sanctioned wallets. 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?

The description is concise, well-structured, and front-loaded with the main action. It uses bullet points for return fields, making it easy to parse. Every sentence adds value without 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?

Given the existence of an output schema detailing return fields, the description covers behavioral completeness: it explains sourcing, caching, fallback behavior, and operational impact. No gaps remain.

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

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

The input schema provides a clear description for the single parameter (wallet_address). Schema coverage is 100%, so the description does not need to add extra meaning. The baseline score of 3 is appropriate as the schema already carries the semantic load.

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 screens an XRPL wallet against the OFAC SDN sanctions list. The verb 'screen' is specific and distinguishes it from sibling tools, none of which perform sanctions checks.

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

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

The description implies usage context by noting that sanctioned wallets cannot participate in AgentTrust escrows and receive a trust score of 0. However, it does not explicitly state when to use or when not to use this tool relative to alternatives, though no direct siblings exist.

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 non-read-only, active behavior. The description adds valuable behavioral detail: immediate award without buyer approval, buyer notified via webhook, and the full 4-step process. This exceeds annotation coverage by revealing the atomic, irreversible nature of the claim and its dependencies.

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 purpose, then provides clear workflow steps, and ends with the return fields. Every sentence adds value. Slight redundancy with 'Only works on jobs where claimable=True' appearing in both the description and the parameter schema, but this reinforces the critical precondition.

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 moderate complexity (4 params, output schema present, many siblings), the description covers all necessary aspects: purpose, precondition, workflow sequence, and output structure. No gaps remain for selecting or invoking 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 coverage is 100%, so baseline is 3. The description adds meaning by providing context for 'job_id' (must come from list_marketplace_jobs with claimable=True) and 'worker_address' (XRPL wallet to receive payment). However, 'worker_name' and 'worker_email' are not given additional context beyond the schema descriptions.

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

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

The description uses a specific verb ('claim an open bounty job') and clearly distinguishes this tool from siblings like 'submit_bid' and 'award_job' by stating it bypasses the bid/award cycle. The unique condition 'claimable=True' further differentiates it.

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

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

The description explicitly states when to use ('only works on jobs where claimable=True') and provides a clear step-by-step workflow sequence showing how this tool fits with 'prepare_escrow' and 'evaluate_escrow_work'. It implicitly tells the agent when not to use (if claimable=False, use bid cycle instead).

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

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

The description discloses that it registers the hash and automatically caches the escrow sequence number, and mentions the return value with 'status' and 'sequence'. Annotations confirm idempotency and non-destructiveness, and the description aligns. No contradictions.

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: three sentences covering purpose, usage instruction, and return value. No extraneous text. 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 tool's simplicity (2 params, annotations present, output schema exists), the description is complete enough. It covers when to use, what it does, and what is returned. Could mention error handling but not essential.

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

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

Schema coverage is 100%, with both parameters fully described. The description does not add meaningful information beyond the schema (e.g., escrow_id is already described as 'receipt code returned by create_escrow_vault'). 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?

The description clearly states the action ('Register the on-chain EscrowCreate transaction hash with the referee') and the resource (transaction hash with referee). It distinguishes from sibling tools like create_escrow_vault or evaluate_escrow_work by specifying this is the confirmation step after creation.

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 after submitting the EscrowCreate transaction on XRPL', providing clear usage context. It does not mention when not to use or list alternatives, but the instruction is direct and sufficient for an agent.

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

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

Annotations indicate non-read-only and non-destructive, but the description adds behavioral context: it stores a WalletVerification record and adds +8 points. This goes beyond annotations, though it doesn't discuss idempotency or potential duplicate side effects.

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

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

Description is concise: four sentences front-loading purpose, followed by process details and return values. No extraneous 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 tool's complexity, full schema coverage, and presence of output schema, the description adequately covers behavior, return values, and context. It is complete enough for an agent to use correctly.

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

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

The input schema covers 100% of parameters with descriptions. The tool description adds context by explaining tx_hash as 'the XRPL transaction hash of the AccountSet tx you submitted with the challenge in a Memo' and wallet_address as 'The XRPL wallet address (r...) you are verifying.' This enhances understanding 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: complete wallet ownership verification using an XRPL AccountSet transaction. It specifies the on-chain lookup, confirmation of source, Memo verification, record storage, and point award. This is distinct from sibling tools like check_wallet_sanctions and get_wallet_verification_challenge.

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

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

The description implies usage after broadcasting an AccountSet transaction but does not explicitly state when not to use or mention alternatives. It lacks guidance on prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: generates keypair, returns sensitive seed, wallet is not funded, and security warning. It could mention that repeated calls create new wallets, but overall sufficient.

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 sections (Returns, Funding options, Security). Each sentence adds value, though it is slightly longer than necessary. Could be tightened but remains effective.

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 zero parameters and an output schema assumed present, the description covers purpose, output, funding requirements, and security. It is complete for an agent to understand and invoke correctly.

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

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

No parameters exist, so schema coverage is effectively 100%. The description adds meaning by explaining the output and post-creation steps, which is appropriate for a parameterless tool.

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

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

The description explicitly states it generates a new XRPL keypair for an agent wallet and returns the address and seed. It clarifies the wallet is not funded, which distinguishes it from funding-related sibling tools like fund_xrpl_wallet_via_coinbase.

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 on when to use (to create a wallet keypair) and what to do next (fund via provided options). It implicitly suggests use before funding but does not explicitly state when not to use or compare to alternatives beyond funding.

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

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

While destructiveHint and openWorldHint are annotated, the description clearly states that the tool 'creates' a vault but also implies destructive actions like cancel_after_hrs potentially affecting funds. It lists the returned fields and mentions 'cancel_after_human', which is a behavioral detail. The description adds value by explaining the AI-gating mechanism and fund release logic, which annotations don't capture.

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 a numbered list and clear returns section. Every sentence adds value: the purpose, the flow steps, and the returned fields. It's appropriately sized for a complex 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?

The tool is complex (13 params, multiple steps), and the description covers the workflow well. It references sibling tools and provides enough context for an agent to proceed. The output schema exists, so returns are documented separately. Loses one point because the description doesn't explain what 'cancel_after_human' is beyond the name, nor does it mention cancellation conditions in detail, but the schema covers all params.

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 context for key parameters like worker_address ('Use the address returned by award_job()') and fee_hash ('payment to the protocol wallet'). It also clarifies the relationship between currency and amount fields. This exceeds baseline by providing cross-parameter guidance.

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 that it creates an AI-gated XRPL escrow vault and outlines the automated fund release mechanism. It distinguishes itself from sibling tools like prepare_escrow and confirm_escrow_transaction by detailing the full workflow steps.

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 step-by-step usage instructions, including prerequisites like paying a protocol fee and obtaining a worker_address from award_job. It also references subsequent steps (confirm_escrow_transaction). This goes beyond mere existence of context and offers actionable guidance.

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

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

The description adds practical behavioral context beyond annotations: listing duration, mandatory external payment, recipient address, and visibility to humans and MCP callers. Annotations already declare readOnlyHint=false and destructiveHint=false, and the description is consistent with those flags.

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

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

Three short, front-loaded paragraphs contain no filler; payment instructions, visibility effects, and the return summary are compactly integrated. Every sentence adds value.

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

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

For a 10-parameter tool with an output schema, the description covers the essential operational workflow: pay the fee, provide the hash, and what happens after listing. It could add edge cases like renewal or cancellation, but it is complete enough for normal 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?

All 10 parameters have descriptions in the schema (100% coverage), so the description is not required to re-document them. It usefully ties fee_hash to the payment step and mentions returned fields, but provides little extra parameter-level 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 opens with a specific verb ('List') and resource ('skill on the AgentTrust marketplace') plus a 30-day duration. This clearly frames it as the creation action for skill listings and differentiates it from sibling tools like post_job or list_marketplace_skills.

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 preconditions: pay the $0.10/month fee to a specific XRPL address and supply the transaction hash as fee_hash before calling. It also explains which audiences will see the listing. It does not explicitly say 'use this instead of post_job' or list exclusions, hence not a 5.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that no funds move and that the return includes escrow creation instructions, which aligns with the safe, read-only nature. No contradictions.

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: first sentence states purpose, followed by usage guidance, workflow steps, and return values. Every sentence adds value with no repetition 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?

Given the simple input (1 param), clear annotations, and existence of an output schema (returns listed), the description is complete. It explains the tool's role in the workflow and what the agent can expect.

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

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

The single parameter skill_id is described in both schema and tool description. Tool description adds context: 'skill listing ID from list_marketplace_skills()' with example 'SKILL-PY-001', which goes beyond the schema's description. Schema coverage is 100%, but the description adds meaningful usage 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 opens with a clear verb+resource: 'Get the wallet address and hiring details for a skill listing — skipping the job board entirely.' It distinguishes itself from sibling tools like award_job and submit_bid by stating it's for direct hiring without the bid/award process.

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: 'when you've found a skill provider via list_marketplace_skills() and want to hire them directly without going through the bid/award process.' Provides a typical flow with steps and clarifies what not to do: 'No funds move — you still create the escrow yourself via create_escrow_vault().'

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 destructiveHint true, but description adds details: auto-finish on approval, ledger verification, and returns on pass/fail including attempts_remaining. 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?

Description is relatively short, front-loads purpose, and efficiently conveys behavior and returns. Minor bullet list of returns is clear.

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

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

Given 5 parameters (2 required) and presence of output schema, the description covers purpose, behavior, and key parameter details. Could mention additional parameters, but schema handles those.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value for the 'work' parameter (XRPL tx hash details) but does not elaborate on other parameters like require_consensus or evidence_links.

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

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

The description states the exact action: 'Submit proof of completed work against an existing escrow vault.' It clearly distinguishes from siblings like create_escrow_vault and get_escrow_info.

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

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

The description provides context: payment releases automatically on approval, no EscrowFinish needed, and XRPL tx hashes are auto-verified. It does not explicitly list when not to use, but implies use cases (e.g., proof of NFT transfers).

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 transparently explains behavioral traits: it reveals the authentication method (HMAC auth via Coinbase v2 API), credential handling (credentials are not shared, held by the server, and can be passed via env vars or directly), and financial implications (charges the user's Coinbase account). It also mentions the autonomous nature after setup ('fully autonomous — no human needed per transaction'). While no annotations exist, the description thoroughly covers key behaviors. It could be a 5 if it also mentioned any error handling or rate limits, but it is already very strong.

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 reasonably concise at about 200 words, with clear sections: purpose, context, important note about credentials, and setup steps. It front-loads the core purpose in the first sentence. However, it could be slightly more concise by merging the credentials note and setup into a more streamlined structure, and some setup steps could be simplified. It avoids fluff but has minor 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 moderate complexity (a financial operation involving two systems), the description is complete: it covers the end-to-end flow (buy XRP, withdraw to XRPL), prerequisites (Coinbase account, KYC, API key setup), credential security model, default amount rationale, and automation capability. An output schema exists but is not shown; even so, the description provides enough context for an agent to decide to use this tool safely and understand its outcomes. No gaps are evident.

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 description is not required to add extensive param details, but it does add value beyond the schema: it explains the default $3 USD amount in context ('covers 1 XRP reserve + Coinbase fees + XRP price variance buffer'), which clarifies why that specific default exists. The description also clarifies that xrpl_address is typically from 'create_agent_wallet', providing a sibling reference. The only minor gap is that it does not elaborate on fallback behavior for coinbase_api_key/secret, but the schema's 'default': '' and description already cover the env var fallback adequately. With high schema coverage, a score of 4 is appropriate for the contextual additions.

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: buying XRP on Coinbase and withdrawing it to an XRPL address in one call. It uses specific verbs ('Buy', 'withdraw') and resource mentions ('Coinbase', 'XRPL address'), and it distinguishes itself from sibling tools like 'create_agent_wallet' (which creates the wallet, not funds it) or 'get_dex_quote' (which only provides quotes). The purpose is explicit and unique.

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 strong usage guidelines: it explains when to use this tool (when a USDC-native or fiat-funded agent needs to bootstrap an XRPL wallet), what prerequisites are needed (a Coinbase account with specific API permissions), and explicitly warns against using shared credentials ('Never use someone else's key'). It also gives a step-by-step human setup process, making it clear what must happen before autonomous use. This is exemplary guideline content.

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, establishing safety. The description adds that the quote is 'live' (implying real-time, not cached) and lists specific return fields (from_amount, to_amount, rate, slippage estimate), which goes beyond the annotations. No contradictions.

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 concise sentences plus a returns line, with no unnecessary words. The purpose and usage are front-loaded, making it easy for an agent to quickly understand the tool's function.

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

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

Given the existence of an output schema (not shown but confirmed), the description does not need to detail every return field but still lists key ones. It provides sufficient context for a straightforward quote tool. Could explicitly state that only XRP/RLUSD pairs are supported, but it is implied.

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 fully documents the three parameters. The description repeats the currency example ('XRP' or 'RLUSD') but does not add new meaning or constraints beyond the schema's 'e.g.' examples. 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 clearly states it retrieves a live DEX price quote for swapping XRP and RLUSD, using specific verbs ('Get', 'price quote', 'swapping'). It distinguishes from siblings like 'get_xrp_price' (simple price) and 'get_rlusd_quote' (likely a different quote type) by specifying the DEX context and the specific trading pair.

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 scenarios: pricing escrows and understanding exchange rates before committing to a job budget. It implicitly differentiates from siblings by focusing on the DEX swap context, though it does not explicitly state when not to use this tool or mention alternatives like 'get_rlusd_quote'.

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 destructiveHint. The description adds that the fulfillment key is never returned, which is critical information beyond what annotations provide. It also lists the returned fields, adding transparency.

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 with two sentences and a list of return fields. It front-loads the key information. The list may be slightly redundant given the output schema exists, but it does not significantly waste space.

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, the description does not need to detail return values. It covers the main purpose and a critical behavioral constraint (no fulfillment key). For a simple read tool, this is complete enough for effective 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?

Input schema coverage for escrow_id is 100% with a clear example ('e.g. AT-7X9K-2MQ4'). The description adds no additional parameter semantics; with full schema coverage, a 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 clearly states 'Retrieve metadata about an existing escrow vault', specifying the verb and resource. It also explicitly notes what is not returned (fulfillment key), distinguishing itself from sibling tools like create_escrow_vault.

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

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

The description implies usage for retrieving metadata without the fulfillment key, but does not explicitly state when to use this tool over alternatives or mention any exclusions. The guidance is adequate but not 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 the tool as read-only, idempotent, and non-destructive. The description adds value by stating what is returned (issuer name, category, website, verification status, domain proof), which is not present in annotations. 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?

The description is concise, with a clear single sentence followed by a list of returned fields. It wastes no words and is front-loaded with the core action. Could be slightly improved by being even more terse, but the structure is effective.

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 low complexity (one parameter, clear purpose), the description is complete. The output schema exists and the description enumerates the returned fields, which reduces the need for detailed return value documentation. The annotations cover safety and behavior well.

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 one required parameter. The description reiterates the parameter's purpose (wallet address for lookup) but does not add new semantic details beyond the schema description. Since schema coverage is high and only one parameter, the baseline of 3 is appropriate, but slight improvement because description explains what happens with the parameter.

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

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

The description clearly states it looks up an NFT issuer by wallet address, specifies the resource (XRPL wallet address) and the purpose (verify identity of an NFT's minting wallet against a registry). It distinguishes itself from siblings like lookup_nft_issuer by specifying the lookup key and the registry context.

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

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

The description explicitly instructs to use this tool to verify whether an NFT's minting wallet belongs to a known, verified organization. It implies a specific usage scenario but does not explicitly state when not to use it or alternatives; however, the context is clear enough for an agent to infer appropriate use.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description adds return fields (estimated_rlusd, trust_line_ok, etc.), providing valuable behavioral context beyond annotations. 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?

Highly concise with three sentences plus bullet list of returns. Front-loaded purpose and usage. No unnecessary words.

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

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

For a simple read-only quote tool with output schema, the description covers purpose, usage, and return values completely. No gaps.

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

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

Input schema coverage is 100% with clear descriptions. Description does not add extra meaning to parameters beyond the schema. Baseline 3 is appropriate.

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

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

Clearly states 'Get a live XRP to RLUSD conversion quote via the XRPL DEX', specifying the action, source, and currencies. Distinguishes from sibling 'get_xrp_price' which is about XRP price, not conversion.

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 context: 'Use before creating an RLUSD-denominated escrow or before claiming an escrow if you want to understand the current USD value.' This guides when to use, though no explicit alternatives or exclusions are given.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the agent knows it's safe. The description adds valuable context: it combines 12 independent signals (e.g., account age, XRP balance, sanctions screening, KYC checks) and returns a full score breakdown for reasoning. 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?

The description is concise (four sentences) and front-loaded with the core purpose. Every sentence adds value: the first defines the score, the second lists the signals, the third specifies use cases, and the fourth provides actionable thresholds. No 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?

Despite the tool involving 12 complex signals (including sanctions screening, KYC, etc.), the description covers the purpose, key use cases, score interpretation, and return format (full breakdown). Since an output schema exists, the agent can infer the exact return structure. The description is complete for this level of complexity.

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

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

The input schema has only one parameter (wallet_address) with 100% schema description coverage. The description adds no additional parameter details beyond what the schema provides, but the schema itself is complete and clear. With a single, well-documented parameter, the tool is self-explanatory.

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

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

The description clearly states it retrieves the AgentTrust Wallet Trust Score (0–100) for any XRPL wallet, which is a specific verb-resource combo. It distinguishes itself from siblings like check_wallet_kyc, check_wallet_sanctions, rate_wallet, and get_wallet_verification_challenge, which cover narrower identity or risk checks. The scope (any XRPL wallet) is unambiguous.

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

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

The description explicitly advises using the tool before 'accepting a job or creating an escrow to assess counterparty risk.' It provides score thresholds (below 30 low-trust, 30–60 moderate, 60+ established) and a concrete use case for KYC-verified wallets (escrow limits). This tells the agent exactly when to invoke this tool versus alternatives like check_wallet_sanctions or rate_wallet.

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

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

Annotations declare readOnlyHint=true, and description confirms it's a read-only request. Discloses expiration time (30 min) and that no private key is transmitted. No contradictions.

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

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

Two concise paragraphs: first states purpose, second gives detailed usage instructions and return fields. No 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?

Complete for a verification step. Includes security context, expiration, follow-up function, and return fields. Output schema exists, so return details are sufficient.

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

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

Only one parameter (wallet_address) with 100% schema coverage. Description adds minimal extra context (r... format), but schema already adequately describes it.

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

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

Clearly states the tool's purpose: requesting a one-time verification challenge to prove XRPL wallet ownership. Distinguishes from sibling tool confirm_wallet_ownership, which is the follow-up step.

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

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

Provides explicit step-by-step instructions: after getting challenge, submit AccountSet transaction with memo hex, then call confirm_wallet_ownership(). Mentions expiration and security note (no private key sent). Clear context and 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering safety. The description adds that the price may be cached if source is briefly unavailable, giving useful edge-case transparency. No contradictions.

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 plus a bullet list of return values. Every word is purposeful, and the key purpose 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?

With zero parameters and an output schema present, the description covers all necessary context: what the tool does, when to use it, and what it returns (usd, gbp, cached flag). No gaps remain.

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

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

There are zero parameters, so the description need not add parameter meaning. Baseline 4 is appropriate as the schema coverage is 100%.

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 'Get the current live XRP price in USD and GBP.' This is a specific verb-resource pair with clear scope. The sibling tools include get_rlusd_quote, so this tool is well-distinguished.

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

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

The description includes 'Use this to convert XRP bounty amounts to fiat before deciding whether a job is worth taking.' This provides clear context for use, though it does not explicitly list when not to use or 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?

With annotations already indicating side effects (readOnlyHint: false), the description adds context about the combined nature, the ready-to-sign transaction, and that no manual construction is needed. It clarifies the immediate output and next steps, which is useful beyond the annotation flags.

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 a clear purpose in the first sentence, a numbered flow, and a return list. It is moderately verbose but each section earns its place, making it efficient and scannable.

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 8 parameters, an output schema, and many related tools, the description covers the essential process, ties into the wider workflow, and explains what the agent must do with the result. It does not over-explain but provides enough to act 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%, and the schema already explains each parameter, including uniqueness and how worker_address is obtained. The description adds flow context but does not meaningfully expand on 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 first sentence clearly states it as a one-call shortcut to register an escrow vault and get a ready-to-sign transaction, combining two specific functions. This distinguishes it from siblings like create_escrow_vault and prepare_escrow.

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 a typical flow with steps, showing when this tool fits in the overall process. It mentions combining create_escrow_vault() and prepare_escrow(), implicitly indicating that separate alternatives exist, but does not explicitly list exclusion conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable behavioral traits: bounties are backed by XRPL escrow and pay automatically upon AI approval, and it explains job statuses (OPEN vs LOCKED) and the effect of claiming. 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?

The description is well-structured with sections for statuses, workflow, and returns. Each sentence serves a purpose. While slightly lengthy, it is front-loaded with the core purpose and avoids fluff.

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

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

Given the tool's simplicity (3 optional params, output schema present, comprehensive annotations), the description covers statuses, workflow, and return structure. It lacks explicit differentiation from sibling list_open_jobs but is otherwise complete for an agent to use effectively.

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 clear descriptions for all 3 parameters. The description does not add new information about parameters beyond what the schema provides (e.g., category enum values). It focuses on workflow and returns, meeting the baseline but not exceeding.

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 'Browse open bounties on the AgentTrust marketplace,' clearly stating the verb 'browse' and resource 'open bounties.' It distinguishes itself from siblings like list_open_jobs by emphasizing marketplace jobs backed by escrow and including a detailed workflow for claiming jobs.

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

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

The description provides explicit usage context: it is the primary tool for discovering open bounties and includes a step-by-step workflow for claiming an OPEN job. It warns against claiming LOCKED jobs but does not explicitly compare with sibling list_open_jobs or specify when not to use this tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds context about return structure, wallet addresses, and how listings work, complementing the annotations without contradiction.

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

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

The description is concise and well-structured: a brief intro, explanatory context, a numbered workflow, and return fields. Every sentence serves a purpose without wordiness.

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

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

Given the presence of annotations, full parameter schemas, and a listing of return fields, the description is complete. It explains the tool's role in a larger workflow and provides sufficient context for an AI agent.

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

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

The input schema already provides full descriptions with defaults and enums (100% coverage). The description hints at filtering by category/rate in the workflow, but this does not add substantial new 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 first sentence clearly states the tool browses marketplace skills, distinguishing it from sibling tools like list_marketplace_jobs. It also explains the purpose of listings and how they facilitate direct hires.

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 outlines a three-step workflow starting with list_marketplace_skills, tells when to use it (to find a provider), and distinguishes it from direct_hire and create_escrow_vault.

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 no destructive action. The description adds valuable behavioral context: no escrow exists yet, workflow steps, and return structure. No contradictions.

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 a clear purpose, workflow, and return structure. It is slightly verbose but not wasteful. The main purpose 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 comprehensive annotations and schema descriptions, the description adds complete workflow context and return details. The tool is adequately documented for an agent to use correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add any additional parameter-level meaning 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 clearly states the verb 'Browse' and resource 'jobs' on the AgentTrust job board, and distinguishes from siblings like list_marketplace_jobs and view_job by specifying 'open for bidding' and the workflow context.

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

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

The description provides explicit usage context within a multi-step workflow, showing when to use this tool (step 1) and mentioning next steps (submit_bid). However, it doesn't explicitly state when not to use it or mention alternative listing 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 indicate read-only, idempotent, and non-destructive behavior. The description adds value by explaining the cryptographic verification via domain records and the return of a register_url when not found, which helps the agent understand the tool's reliability and edge cases without contradiction.

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

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

The description is three sentences, each serving a distinct purpose: definition, context/use case, and return values. No word is wasted, and the information is front-loaded with the core action.

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 the registry purpose, verification method, usage scenario, and return fields, which is sufficient for a simple lookup tool. However, it does not differentiate from the sibling tool get_nft_issuer_by_wallet, which could be confusing for an agent choosing between them.

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 100% coverage for the single parameter, including an example. The description does not add any additional meaning beyond what the schema already states, 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 clearly states the tool looks up an organisation in the AgentTrust XRPL NFT Issuer Registry, mapping company names to verified wallet addresses. It provides a specific use case (checking NFT issuer legitimacy) and lists return fields, making the purpose unmistakable and distinct from generic lookup tools.

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

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

The description explicitly says to use this tool before accepting an NFT as proof of ownership or in escrow, giving a concrete scenario. However, it does not mention when not to use it or suggest alternatives (e.g., get_nft_issuer_by_wallet for wallet-only lookups), which limits full 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?

Discloses that the tool is free and non-destructive, and specifies the return fields (status, job_id, expires_at, next_step). Annotations already indicate openWorldHint=true and readOnlyHint=false; the description adds workflow context beyond these.

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

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

Description is front-loaded with the main action and returns, but includes workflow details that could be separated. Still concise and efficient.

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

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

With 8 parameters (4 required), 100% schema coverage, annotations, and an output schema, the description provides a useful workflow and return values, making it fairly complete for an agent to use.

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

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

Schema coverage is 100% and the description does not explain individual parameters, but it adds context for budget_xrp as 'Indicative maximum budget'. Baseline at 3 is appropriate since schema already documents all parameters.

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

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

Clearly states 'Post a job to the AgentTrust job board' and distinguishes from siblings (award_job, submit_bid) by outlining the workflow.

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

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

Provides explicit when-to-use context ('No fee, no funds held') and a step-by-step workflow (list_open_jobs → submit_bid → award_job → create_escrow_vault), guiding the agent on 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?

The description states that the tool pre-fills the transaction with 'the current ledger sequence,' implying the output depends on time of call. This contradicts the annotation's idempotentHint: true, which claims the tool produces the same output for the same input. The description does not add behavioral context beyond the 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?

The description is roughly 150 words, well-structured with a main sentence, numbered steps, and a bullet list of return values. It is front-loaded with the core purpose. Minor redundancy ('no XRPL library required' and 'never has to construct') could be trimmed, but overall efficient.

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

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

Given the tool's complexity (5 parameters, workflow dependency, output schema exists), the description covers the full usage lifecycle: prerequisites, tool output, post-invocations. It explains what the returned transaction dict contains and lists all return fields. No critical gaps remain for an agent to understand invocation and outcome.

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?

All 5 parameters are described in the schema (100% coverage). The description does not add new semantic details about the parameters, only reiterates the escrow_id's purpose ('receipt code from create_escrow_vault()'). Baseline 3 is appropriate since the schema already carries the load.

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: 'Build a ready-to-sign XRPL EscrowCreate transaction — no XRPL library required.' It names the specific operation (prepare_escrow) and distinguishes it from sibling tools like create_escrow_vault and confirm_escrow_transaction by outlining the workflow order.

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 step-by-step usage instructions: call create_escrow_vault() first, then this tool, then buyer signs and submits, then confirm_escrow_transaction(). It names the required predecessor and successor tools, giving clear context for when to invoke this tool.

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

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

The annotations provide 'readOnlyHint=false' and 'destructiveHint=false', so the user already knows this is a write but non-destructive action. The description adds helpful behavioral context: ratings are 'permanent and public,' feed into a trust score ('up to 15 pts'), and are allowed after both passed and failed escrows. This is valuable beyond the annotations.

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

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

The description is three short, well-structured sentences. The first sentence states the core action, the second sentence adds key behavioral implications (trust score impact permanence), and the third sentence provides usage timing. Every sentence earns its place without redundancy or fluff.

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

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

Given the tool's moderate complexity (6 params), rich input schema, output schema presence, and the annotations, the description provides a complete enough picture: purpose, trigger condition, invariants (one-rating rule permanence public), and ecosystem effect. Minor gaps: it doesn't describe the output format or errors (though output schema handles that), and the 1-5 star scale is already in the schema. A 4 acknowledges strong coverage but slight room to add a note about idempotency or duplicate 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 covers all 6 parameters with descriptions, achieving 100% schema_description_coverage. The description adds general purpose context but does not significantly elaborate on the meaning of individual parameters beyond what the schema already provides. For example, it doesn't explain what happens if 'comment' is omitted or how 'rater_role' affects the rating. However, since schema coverage is complete, a 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?

The description explicitly states the action ('leave a 1–5 star peer rating'), the target ('counterparty'), and the required trigger context ('after a completed escrow'). This clearly distinguishes it from sibling tools like 'get_wallet_trust_score' (which reads a score) or 'evaluate_escrow_work' (which might be work-specific).

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 on when to call the tool ('after an escrow completes') and the purpose ('to build an honest reputation record'). It mentions the constraint of 'one rating per escrow per rater.' However, it does not explicitly state when NOT to use it (e.g., if escrow is still active or if you are not the rater) or name specific alternative tools for non-rating actions, so a 4 is warranted.

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=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds context about chronological ordering and content (messages from buyers and workers). However, it does not disclose potential pagination, message limit, or whether only recent messages are returned. Given annotations handle the main behavioral traits, a 3 is appropriate.

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 appropriately sized three sentences, each earning its place: first sentence states purpose, second describes content/ordering, third gives usage guidance. It is front-loaded and clear with no waste. Minor deduction for slightly verbose second sentence ('posted by buyers and workers on this job') which is redundant given 'message thread' context.

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

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

Given the tool is simple (1 required param, clear annotations, output schema exists), the description is largely complete. It explains the type of content (messages, chronological), ordering, and usage context. With output schema present, return value explanation is not needed. The only minor gap is lack of mention of pagination or message limits, but for a straightforward read tool this is acceptable.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter succinctly ('The job ID to fetch messages for.'). The description does not add any new parameter-level meaning beyond what the schema provides. 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?

The description clearly states 'Fetch the message thread for a job' with specific verb and resource, and distinguishes it from siblings like 'send_job_message' which sends rather than reads messages. However, it could be slightly sharper by explicitly noting it is read-only versus write 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 provides clear use-case guidance: 'Use this to catch up on any clarifications or instructions before starting work or submitting a bid.' This gives explicit context for when to invoke the tool. However, it does not explicitly state when not to use it or mention alternatives, though the purpose is clear enough given sibling distinctions.

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 (which indicate a write operation but not destructive), the description adds that messages are visible to both buyer and worker. This is a key behavioral trait. It does not cover aspects like immediate sending, moderation, or immutability, but the added visibility context is valuable.

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

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

The description is two sentences, front-loaded with the core action, and includes a second sentence for context. Every sentence earns its place with no unnecessary 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 has 5 parameters (3 required) and an output schema (not shown), the description covers the purpose, visibility, and typical usage scenarios. It does not explain the output, but that is acceptable since an output schema exists. The description is slightly incomplete about whether messages can be sent after escrow creation, but overall it is sufficient.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add additional meaning beyond what the schema already provides for parameters like job_id, message, sender_role, etc. It repeats the purpose but not the 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 clearly states 'Send a message on a job thread' and provides specific use cases: clarifying requirements, sharing progress, or negotiating. This distinguishes it from sibling tools like read_job_messages, which only read messages.

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 explains when to use the tool (for job-related communication) and that it's for communicating within the platform. However, it does not explicitly state when not to use it or compare it to alternatives like email or other messaging 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 indicate this is a non-read-only, non-destructive action. The description adds context about email notifications for humans and polling for agents, which is not in annotations. It could mention if bids can be updated, but overall good.

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: purpose, process, human/AI guidance, return values. No fluff, front-loaded key information.

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

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

Given the parameter count and output schema, the description covers the essential workflow. It could be more explicit about bid finality but is sufficient.

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

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

With 100% schema coverage, the baseline is 3. The description adds value by clarifying when worker_email is needed (humans vs agents) and that poll view_job replaces email for agents.

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 'Submit a bid on an open job posting,' clearly stating the action and target. It distinguishes itself from sibling tools like award_job and view_job by referencing 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?

It explains the buyer's review and award process via award_job(), and provides separate guidance for human workers (use email) vs AI agents (poll view_job). This tells when to use each tool.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It reveals the key behavioral trait of activating the vault in one step without a separate confirm call, but lacks details about error handling, irreversibility, resource consumption, or what happens if the transaction blob is invalid. While useful, it leaves significant behavioral gaps.

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

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

The description is a single sentence of 18 words that front-loads the core action and includes a crucial distinction from a sibling tool. Every word provides information—no 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?

Given the tool has only two parameters and an output schema exists, the description covers the essential purpose and distinctive behavior (one-step activation). It is adequate for an agent to understand what the tool does and how it relates to other escrow operations, though it could briefly mention that the blob must be properly signed or the outcome if the transaction fails.

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 descriptions in the schema already document both parameters. The tool description adds unique value by specifying the source of escrow_id (hire_and_pay() or create_escrow_vault()), which is not present in the schema. It does not add detail for tx_blob beyond 'locally-signed', which is partly already in the schema, but the added context elevates 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 clearly states it submits a locally-signed EscrowCreate transaction blob and activates the vault in one step, distinguishing itself from the sibling tool 'confirm_escrow_transaction' by noting no separate confirm call is needed. The verb 'submit' and resource 'EscrowCreate transaction' are specific and 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 implies usage context by stating the escrow_id comes from hire_and_pay() or create_escrow_vault(), giving agents a clear precondition. It also distinguishes from confirm_escrow_transaction, but does not explicitly state when not to use this tool (e.g., if the escrow has already been activated, or if a different submission method is needed).

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 destructiveHint=false, so the behavioral safety profile is clear. The description adds value by specifying the return structure ('Returns: verified (bool), nft_token_id, metadata match result, and issuer details'), going beyond the boolean implied by 'verify'. This helps the agent understand the richness of the output.

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

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

Five well-structured sentences: first states core purpose, second and third give usage context and automation hint, fourth mentions automatic invocation, fifth lists output fields. Every sentence earns its place with no redundancy. Front-loaded with the most important information.

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

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

Given the tool's moderate complexity (3 params, 2 required, output schema exists, all schema descriptions present), the description provides sufficient contextual detail: purpose, usage scenario, automation context, and output structure. It does not explain the exact format of required_metadata (JSON syntax), but the schema handles that. The annotations cover behavioral traits. Overall, the agent has enough to invoke correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions the three parameters (wallet_address, issuer_wallet, required_metadata) but does not add any additional semantic nuance beyond what is already in the schema descriptions. It correctly maps to the params but provides no extra value.

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 'Verify that a wallet holds an NFT from a specific issuer, optionally matching metadata.' This is a specific verb+resource combination. It also provides context of use in escrow delivery conditions, differentiating it from sibling tools like check_wallet_kyc or get_wallet_trust_score.

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 guides when to use: 'Use as an escrow delivery condition: before releasing payment, confirm the seller has transferred the correct NFT to the buyer's wallet.' It also notes that the AgentTrust AI evaluator calls it automatically or it can be called manually. It stops short of naming alternatives or when not to use, but the context is very 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 provide idempotentHint=true and readOnlyHint=false, and the description adds important behavioral info: it contributes 10 points to the trust score and returns detailed verification results. However, it does not clarify whether the trust score increase happens every call or only once, creating slight ambiguity with the idempotency hint.

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 efficiently structured: a clear first paragraph stating purpose and method, followed by a second paragraph detailing the mechanism and return values. No redundant sentences, front-loaded with the core action.

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 the purpose, mechanism, return values, and side effect. It does not mention error handling or what happens when the domain lacks the toml file, but given the output schema likely handles errors, this is a minor gap. Overall adequate for the tool's complexity.

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

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

Schema coverage is 100% with good descriptions, and the description adds value by clarifying that the domain must have an xrp-ledger.toml file listing the wallet. This constraint is not in the schema, helping the agent understand the prerequisite. Baseline 3 is elevated due to this extra 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 clearly states the tool's purpose: verifying XRPL wallet ownership of a specific domain via the xrp-ledger.toml standard. It specifies the verb 'verify', the resources (wallet and domain), and the method. The unique side effect of adding 10 trust score points distinguishes it from sibling tools like 'verify_nft_ownership' or 'confirm_wallet_ownership'.

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 explains the mechanism (domain must have xrp-ledger.toml) and what the tool does, but it does not explicitly state when to use this tool versus alternatives like 'confirm_wallet_ownership' or 'verify_nft_ownership'. The usage context is implied by the specific standard, but lack of explicit guidance lowers the score.

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, etc. The description adds valuable detail about the return structure (job details + bids list with specific fields) and status interpretation, exceeding annotation coverage.

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

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

Three sentences, front-loaded with core purpose, efficient with no wasted words. Every sentence adds value.

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

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

Given the presence of an output schema and only one parameter, the description adequately covers the tool's behavior, including return structure and status specifics.

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

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

Schema coverage is 100% for the single parameter 'job_id', which has a clear description. The description adds no extra parameter details, so baseline 3 is appropriate.

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

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

The description clearly states 'View a job posting and all current bids' with a specific verb and resource. It is distinguished from siblings like list_open_jobs and post_job.

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

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

Explicitly says 'Use this to check the status of a job you posted or bid on' and explains interpretation of awarded status. While not exhaustive, it provides clear use context.

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