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

Annotations already provide readOnlyHint=true and openWorldHint=true. The description adds value by disclosing the cost ($0.005 USDC per call) and the input style ('pass fields directly as typed arguments'). However, it does not discuss behavior on invalid inputs, rate limits, or response specifics, making it adequate but not thorough.

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

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

The description is very short (two sentences) and front-loaded with the tool name and key attributes (cost, read-only). Every sentence provides some value, though the lack of detail on purpose and parameters prevents a perfect score.

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 a single parameter, annotations, and an output schema (not shown), the description is somewhat complete. It mentions cost and safety, but lacks context on when to use it among many wallet-related siblings and does not describe the output or prerequisites.

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

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

The schema has 100% coverage with one parameter 'address' described only as 'address parameter'. The description adds 'Pass the listed fields directly as typed arguments', which is a usage instruction rather than semantic clarification. It does not explain what type of address (e.g., blockchain, agent wallet ID) is expected, so the agent gains little extra meaning.

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

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

The description says 'Agent wallet info' which is vague and lacks a specific verb (e.g., 'retrieve' or 'get'). It implies the tool provides information about an agent wallet, but the action is not explicitly stated. The added context of cost and read-only helps slightly, but the core purpose is unclear compared to siblings like 'spraay_agent_wallet_predict' which has a clearer verb.

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

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

No guidance is given on when to use this tool versus alternatives like 'spraay_agent_wallet_predict' or 'spraay_agent_wallet_provision'. The description only states 'Read-only' and 'Pass the listed fields directly as typed arguments', which are not usage guidelines for selecting the 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 provide readOnlyHint and openWorldHint. Description adds cost ($0.001 USDC) and reasserts read-only, but no additional behavioral details beyond what annotations convey.

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

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

Two sentences, no waste. First sentence states purpose, second adds cost and safety context. Efficient and front-loaded.

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

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

With output schema present and high schema coverage, the description sufficiently covers key aspects. It could explain what prediction is based on, but overall adequate.

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

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

Schema coverage is 100% with parameter descriptions. Description only instructs to pass fields directly, adding no semantic meaning 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 'Predict wallet address' using a specific verb and resource. Distinguishes from sibling tools like wallet_info, wallet_provision, which have different purposes.

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?

Mentions cost and read-only nature, which helps decide when to use, but does not explicitly state when not to use or compare with sibling tools. No alternatives named.

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 mutation (readOnlyHint=false). Description adds cost ($0.05 USDC) and states it's a provisioning action, but does not disclose idempotency, side effects, or authorization needs. Provides some value beyond annotations.

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

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

Two sentences: first states purpose, second adds cost and a prompt. No unnecessary words. Front-loaded with 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?

Covers basic purpose and cost, but lacks prerequisites, error handling, and output details (though output schema exists). Adequate but with gaps.

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

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

Schema descriptions are tautological (e.g., 'agentId parameter'), offering no added meaning. The tool description only says 'Provide the listed fields as typed arguments,' which is obvious. Despite 100% schema coverage, semantics are poor.

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 'Provision agent wallet' uses a specific verb and resource, clearly indicating the tool creates or sets up an agent wallet. It distinguishes from sibling tools like info, predict, revoke_key, and session_key, which serve different purposes.

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

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

No guidance on when to use this tool versus alternatives. Does not mention prerequisites (e.g., agent existence, funding) or exclusion criteria (e.g., if wallet already exists).

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 mutability and non-destructiveness. Description adds only cost info, not behavioral details like side effects or return behavior.

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

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

Two short, front-loaded sentences. First states purpose, second adds cost and instructions. No wasted words.

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

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

Missing prerequisites, error conditions, and context about revocation effects. Output schema exists but not described. Incomplete for a mutation tool.

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

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

Schema descriptions are tautological (e.g., 'walletAddress parameter'). Tool description adds no parameter meaning beyond schema.

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

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

Description clearly states 'Revoke session key,' specifying verb and resource. It distinguishes from sibling 'spraay_agent_wallet_session_key' which likely creates/manages keys.

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?

Mentions cost and to provide fields, but lacks when-to-use, prerequisites, or alternatives. No guidance on when not to use.

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

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

The description adds cost information which supplements annotations. Annotations indicate readOnlyHint=false and destructiveHint=false, so it's a non-destructive mutation. The description does not contradict annotations but does not elaborate on other behaviors like idempotency or error conditions. It adds some value beyond structured fields.

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

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

The description is very concise, two sentences, with the purpose and cost front-loaded. Every sentence serves a purpose without fluff, making it efficient for quick understanding.

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 (4 required params, mutation, cost), the description lacks context on prerequisites, return values (though output schema exists), failure modes, or the purpose of a session key. More information is needed for an agent to use it 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 descriptions are trivial ('durationHours parameter'), and the description only says 'Provide the listed fields as typed arguments,' adding no extra meaning. With 100% schema coverage, baseline is 3, and the description does not enhance parameter understanding.

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

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

The description states 'Add session key' as a clear verb+resource, indicating the tool's action. However, it does not explicitly differentiate from sibling tools like spraay_agent_wallet_revoke_key, which may also involve keys. The purpose is clear but lacks sibling distinction.

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

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

The description mentions a cost of $0.02 USDC per call, which is a usage guideline, but does not specify when to use this tool vs alternatives (e.g., revoke_key). There is no guidance on prerequisites (e.g., wallet existence) or context for the session key addition.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description adds value by noting the cost ($0.003 USDC). However, it lacks details on behavior beyond cost, such as rate limits, data freshness, or behavior for invalid addresses. The description does not contradict annotations, so no contradiction flag.

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

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

Two concise sentences: first explains the function and output, second mentions cost. Every sentence serves a purpose with no fluff. The description 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?

With an output schema present, the description does not need to elaborate on return values. It covers the core purpose, scope (Base chain), and cost. Minor gaps exist (e.g., error handling, but those are acceptable for a simple read-only tool). The description is largely complete for its 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 each parameter documented (address pattern, limit default/max). The description adds no additional insight into parameter meaning or usage beyond what the schema already provides, earning the baseline score of 3.

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

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

The description clearly states the tool's function: 'Get decoded transaction history for any address on Base.' It specifies the returned data types (transaction types, values, timestamps, decoded method calls) and includes cost. This distinguishes it from sibling tools like spraay_analytics_wallet which likely focus on portfolio, not transaction history.

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

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

The description provides the use case ('transaction history for any address on Base') but does not explicitly guide when to use versus alternatives or mention exclusions. Given the large set of sibling tools, more explicit differentiation would be helpful, but the purpose is clear enough for basic selection.

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 and openWorldHint=true, establishing a safe read operation. The description adds value by specifying the cost, the Base chain focus, and the components of the profile (balances, age, classification, portfolio), providing behavioral context beyond the annotations.

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

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

The description is a single, well-structured sentence that front-loads the primary action ('Get a comprehensive wallet profile') and efficiently conveys scope, content, and cost. No wasted words.

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

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

The tool has an output schema (not shown) and the description lists key data fields, so the description is sufficiently complete for an agent to understand the tool's output. However, given the large number of sibling tools, a brief note on differentiation would enhance completeness.

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

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

Schema coverage is 100%, and the parameter 'address' is already well-described in the schema with a pattern and example. The description does not add additional meaning or constraints beyond the schema, so 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 the verb 'Get' and resource 'comprehensive wallet profile', listing specific data points (ETH + token balances, wallet age, etc.). However, it does not explicitly distinguish this tool from the sibling 'spraay_agent_wallet_info', which may cause confusion.

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

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

The description mentions the cost ($0.005 USDC), which is a practical guideline. However, there is no explicit statement about when to use this tool versus alternatives, nor any exclusion criteria. Usage context is implied but not fully articulated.

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

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

The description adds behavioral context beyond annotations: immutability, persistence in Supabase, and cost ($0.001 USDC). No contradiction with annotations. Does not detail auth requirements or rate limits, but 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?

Two concise sentences. Front-loaded with purpose and includes key details (immutability, storage, cost). No wasted words.

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

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

Given output schema exists, return value explanation is not needed. Description covers purpose, usage examples, persistence, and cost. Lacks explicit mention of required fields but schema covers that. Adequate.

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

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

Schema coverage is 100% with each parameter described. The description does not add extra meaning beyond the schema, but the schema itself is clear. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Record' and the resource 'audit trail entry'. It specifies types of events (payments, escrows, compliance actions) and differentiates from sibling spraay_audit_query which is for querying.

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

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

The description does not explicitly state when to use this tool versus alternatives. It mentions immutability and cost, but lacks guidance on when not to use it or comparison with other log-related 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 declare readOnlyHint and openWorldHint, so safety is clear. Description adds that data persists in Supabase and costs $0.005 per query, but does not disclose rate limits, authentication requirements, or default behavior when no parameters are provided.

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 cover core functionality, sorting, and cost. Front-loaded with the main action. No redundant 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?

Output schema exists, so return type is covered. However, the description does not specify default behavior when no filters are applied (e.g., returns most recent entries), nor does it mention pagination beyond the limit parameter. For a tool with all optional parameters, more context on expected output with no filters would improve completeness.

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

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

Schema coverage is 100% with descriptions for all 6 parameters. The description reiterates filter dimensions (actor, action, resource, time range) but adds no new meaning beyond the schema. No parameter relationships or combinations are explained.

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

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

Description clearly states the tool queries the audit trail with filters (actor, action, resource, time range) and returns sorted results. The name 'audit_query' contrasts with sibling 'spraay_audit_log' (likely a write tool) and 'spraay_logs_query' (for general logs), but the description does not explicitly distinguish 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?

No guidance on when to use this tool vs alternatives like spraay_logs_query or spraay_audit_log. The description does not mention prerequisites, when not to use, or trade-offs.

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

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

Annotations (readOnlyHint=false, idempotentHint=false, destructiveHint=false) already indicate non-read-only and non-idempotent. The description adds value by disclosing persistence in Supabase, cost per use, and the token format. This goes beyond annotations and helps the agent understand side effects and costs.

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 only three sentences, each serving a distinct purpose: purpose, token usage, and cost/persistence. It is front-loaded with the most critical information, with zero wasted words.

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

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

Given the output schema exists (not shown in description but indicated by context signals), the description covers all essential aspects: creation, scoping, TTL, token return, persistence, and cost. It is fully adequate for a tool of this 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 clear descriptions for all three parameters (address, ttlSeconds, permissions). The description does not add extra parameter-specific meaning beyond what the schema provides, so it meets the baseline expectation without further enhancement.

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 'create' and the resource 'authenticated session', with specifics about scoped permissions, TTL, and token format (spr_...). This effectively distinguishes it from sibling tools like spraay_auth_verify, which handles verification.

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 important context: data persistence in Supabase and a cost of $0.005 USDC, implying it is a paid operation. However, it does not explicitly state when to use this tool versus alternatives (e.g., spraay_auth_verify). The cost hint guides usage, but explicit when-not or alternatives are missing.

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 and openWorldHint=true. The description adds useful behavioral context: data persists in Supabase and costs $0.001 USDC, which goes beyond the annotations.

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

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

Three sentences, front-loaded with the main purpose, followed by two concise contextual sentences. No unnecessary words or repetition.

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

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

For a simple tool with one parameter, explicit output schema, and annotations, the description covers purpose, behavior, and cost sufficiently. 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?

Schema coverage is 100% and the token parameter is well-described with example format. The description does not add extra meaning for the parameter beyond what the schema provides.

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

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

The description clearly states the verb 'Verify' and resource 'session token', and lists the specific checks (permissions, expiry, associated address). It distinguishes from sibling tools like spraay_auth_session which likely creates sessions.

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 lacks explicit guidance on when to use this tool versus alternatives. It does not mention when not to use it or provide context for selection among sibling auth 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 (readOnlyHint, openWorldHint) already indicate a safe, read-only operation. The description adds valuable context: the cost ($0.002 USDC) and that balances are returned with USD values where available. No contradictions; the description enriches the behavioral profile beyond annotations.

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

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

The description is two sentences, front-loaded with the core purpose and expected output, followed by cost. No unnecessary words; every sentence earns its place. Ideal conciseness for a simple tool.

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

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

Given the tool's simplicity and the presence of an output schema, the description is complete. It covers what the tool does, its chain scope, return format, and cost. No missing critical information for an agent to decide to invoke it.

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

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

Schema coverage is 100% and descriptions for each parameter are clear (e.g., tokens as comma-separated addresses, showAll as include zero balances). The description adds little extra meaning beyond 'Get ETH + ERC-20 token balances', which aligns with the address parameter. Minimal added value over 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 gets ETH and ERC-20 token balances for any wallet on Base, with formatted balances and USD values. It distinguishes from siblings like spraay_portfolio_tokens by specifying the chain (Base) and the scope (any wallet). The action verb 'Get' is specific and appropriate.

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 checking balances on Base, but does not explicitly guide when to use this tool over alternatives (e.g., spraay_portfolio_tokens, spraay_free_prices). No when-not or context exclusions are provided; the usage context is only implied.

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 clarity beyond annotations by stating it's an estimate (non-mutating despite readOnlyHint=false), returning gas in wei and USD, and costing $0.001 USDC. 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 two concise sentences, front-loaded with purpose and immediately followed by return and cost details. No wasted words.

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

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

Given an output schema exists, the description is fairly complete, covering the return type and cost. Could mention prerequisites like having a funded wallet or chain context, but not critical.

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 does not add additional meaning to the parameters beyond what the schema already provides (token default, recipientCount range).

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 estimates gas cost for a batch payment, with specific verb 'estimate' and resource. However, it does not explicitly differentiate from other estimate tools like spraay_stellar_estimate or spraay_free_estimate_batch, which are for different contexts.

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 implies usage before executing a batch payment ('before executing') and mentions a cost of $0.001 USDC, but does not provide explicit when-to-use/when-not-to-use guidance or mention alternatives like spraay_batch_execute.

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 confirm non-read-only and non-destructive behavior. The description adds cost ($0.01 USDC), return type (unsigned transaction data), and token support. No contradictions with annotations. Could mention side effects like deducting fees or requiring wallet approval, 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?

Two sentences, no redundant information. Every sentence adds value: purpose, constraints, return type, cost. Highly efficient and front-loaded.

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

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

With 4 required parameters and an output schema (not shown but present), the description covers the core functionality, return type, and cost. It lacks prerequisites (e.g., active wallet or funds) but is mostly complete for an execution tool. Output schema handles return details.

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

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

Schema coverage is 100% with all parameters described. The description adds context about the batch (up to 200 recipients) and token formats (symbol or address), but does not significantly expand beyond schema. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Execute', resource 'batch payment', and key constraints: up to 200 recipients, single Base transaction via Spraay protocol. It distinguishes from siblings like spraay_payroll_execute by specifying the batch nature and protocol.

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 batch payments but does not explicitly state when to use or avoid this tool versus alternatives like spraay_batch_estimate. No exclusions or comparative guidance are provided.

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

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

Annotations are present but the description adds only the cost ($0.03 USDC per call). No other behavioral traits like permissions, rate limits, or error handling are disclosed. The 'openWorldHint' annotation suggests the tool may have side effects beyond the obvious, but the description does not elaborate.

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 at two sentences, front-loaded with the purpose. However, it could be more structured with dedicated sections. No wasted words.

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

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

Given the tool's complexity (4 parameters, 2 required, output schema exists), the description is very incomplete. It does not explain the expected format of messages, the role of model, or the effect of optional parameters. Costs are mentioned but no further context about the inference behavior.

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

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

Schema coverage is 100% with parameter descriptions, but they are tautological ('model parameter', 'messages parameter'). The description adds 'Provide the listed fields as typed arguments' which adds no semantics. Baseline 3 is appropriate as the description neither enhances nor harms parameter understanding.

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

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

The description states 'Bittensor inference' which gives a general idea but lacks specificity. It does not explicitly mention chat completions or differentiate from sibling tools like spraay_bittensor_embeddings. The name provides some clarity, but the description must stand alone.

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

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

No guidance on when to use this tool versus alternatives. It does not mention prerequisites, context, or when to avoid this tool. Users are left to infer from the name alone.

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

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

Annotations are sparse (no readOnly, idempotent, or destructive hints). The description adds only the cost and a generic instruction to provide typed arguments. It does not disclose side effects, required permissions, or any behavioral quirks beyond what annotations already declare. With openWorldHint=true, the description should explain that the schema may not fully constrain inputs, but it does not.

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

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

The description is very short (3 sentences) and front-loaded. However, the brevity comes at the cost of missing critical details like the action verb and parameter semantics. It is not well-structured; the cost is mentioned but not placed in context of usage.

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 a similar sibling tool ('spraay_compute_embeddings'), the description is insufficient for correct selection. It does not differentiate from compute_embeddings. Although an output schema exists, the description does not leverage it to explain expected results. The tool is simple (2 params), but even so, completeness is lacking.

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

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

The input schema has 100% coverage but the parameter descriptions are tautological ('input parameter', 'model parameter'). The description adds no meaningful semantics beyond the schema, only a redundant instruction to provide typed arguments. It fails to explain what values are expected for 'model' or 'input' (e.g., text, IDs).

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 'Bittensor embeddings' is a noun phrase lacking an explicit verb. It does not clearly state that the tool generates or creates embeddings, leaving the action ambiguous. It is not a tautology because it provides some resource context, but it is vague.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'spraay_compute_embeddings'. The cost mention ('Costs $0.005 USDC per call') is a constraint but does not help the agent decide between similar tools. No exclusions or usage contexts 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description's 'Read-only' adds little. It does add that query parameters should be passed as a JSON string via 'params', which is useful. However, it does not disclose any side effects or specific behavior (e.g., what endpoints are called, how parameters map).

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

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

The description is very short (3 sentences) but fails to convey essential information about the tool's purpose. It is under-specified rather than concisely informative.

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 that an output schema exists, the description does not need to detail return values. However, it does not explain what 'health' entails, what query parameters are accepted (no examples or valid keys), or how the output relates to user needs. The description is incomplete for a health-check tool.

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

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

Schema description coverage is 100% (the one parameter has a description). The description repeats the schema's guidance ('Pass any query parameters as a JSON string via the params argument') without adding new meaning or examples of valid parameter keys.

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 says 'Bittensor health' but does not specify what aspect of health is checked (network status, validator health, etc.). It is vague and lacks a specific verb-resource combination, making it hard to distinguish from other bittensor tools like spraay_bittensor_chat_completions or spraay_bittensor_models.

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

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

The description states 'Free to call' and 'Read-only', which implies safe usage but does not provide explicit guidance on when to use this tool versus alternatives or when not to use it. No sibling differentiation is mentioned.

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

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

The annotations are minimal (readOnlyHint, destructiveHint, idempotentHint set to false, openWorldHint true). The description adds the cost per call, which is valuable beyond annotations, but does not disclose other behavioral traits like failure modes, rate limits, or auth requirements.

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

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

Two sentences are concise and front-loaded with the core purpose. However, the second sentence is somewhat redundant and could be omitted or integrated.

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 having an output schema, the description lacks context on return values, potential errors, or constraints on input fields like size or model. For a tool with 4 parameters, more guidance on how to use them effectively is expected.

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, but the description adds no meaningful semantics beyond the parameter names. The phrase 'Provide the listed fields as typed arguments' is redundant and does not clarify parameter formats, constraints, or default values.

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

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

The description clearly states it is for image generation on Bittensor and mentions the cost, making the purpose clear. However, it does not explicitly differentiate from sibling image generation tools like spraay_compute_image_generation, but the name and context are sufficient.

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

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

No guidance is provided on when to use this tool versus alternatives like spraay_compute_image_generation. The cost hint is useful but insufficient for deciding between similar 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?

The description adds cost information ($0.001 USDC per call) beyond the annotations, which is valuable. It confirms read-only behavior, aligning with annotation. 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 short (three sentences) and front-loaded with the vague purpose. It could be improved by adding a verb, but it is not verbose.

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

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

Despite having an output schema, the description fails to clarify what the tool does with 'Bittensor models' or what the output represents. The purpose is too vague for an agent to confidently select this tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds 'any query parameters' which slightly clarifies flexibility, but largely repeats the schema.

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

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

The description states 'Bittensor models' without a verb, leaving ambiguity about whether it lists, retrieves, or queries models. It does not clearly specify the action performed, making it vague compared to sibling tools with clearer names.

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?

There is no explicit guidance on when to use this tool versus other Bittensor tools like spraay_bittensor_chat_completions or spraay_bittensor_embeddings. The cost and read-only nature are mentioned but not in a decision-making context.

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

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

Annotations already indicate readOnlyHint and openWorldHint. Description adds cost information ($0.001 USDC) and return content, which are useful beyond annotations.

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

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

Two concise sentences, front-loaded with key action 'List all chains'. No unnecessary information.

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

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

Complete for a parameterless tool with output schema: description covers return content (chain names, IDs, supported tokens) and cost.

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, so description does not need to add any. Baseline 4 applies.

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

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

Description explicitly states it lists all chains supported by the Spraay bridge aggregator (LI.FI) and specifies return fields (chain names, IDs, supported tokens). Clearly distinguishes from siblings like spraay_bridge_quote.

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?

Implied usage for getting supported chains before bridging, but no explicit when-to-use or when-not-to-use guidance 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?

Discloses cost ($0.005 USDC), which is critical behavior beyond annotations. Annotations show readOnlyHint=false, but description clarifies it's a paid quote. Could add more about validity period or execution guarantees.

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 main purpose. No wasted words. Efficient and clear.

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

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

Description covers cost, supported chains, and return info (estimated output, fees, execution time). Output schema exists so return details are complete. Could mention if quote is valid for limited time.

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

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

Schema has 100% coverage with descriptions. Description adds no extra parameter details beyond listing supported chains, which is already in schema descriptions. Baseline 3 for high schema coverage.

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

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

Description clearly states it gets a cross-chain bridge quote via LI.FI aggregator, listing many supported chains. Differentiates from siblings like spraay_bridge_chains (chains list) and spraay_swap_quote (single-chain swap).

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 (getting a cross-chain quote) and implicit context from siblings. Does not explicitly exclude single-chain swaps or alternatives, but purpose is clear enough.

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

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

Annotations already indicate readOnlyHint=false and openWorldHint=true. The description adds cost information ($0.005 USDC) and states it returns a completion, providing utility beyond annotations. No contradictions found.

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

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

The description is two sentences long, front-loaded with the core action, and contains no redundant information. Every word 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?

The description covers the tool's purpose, required prerequisite (model discovery), and cost. An output schema exists, so return value explanation is unnecessary. It omits potential error scenarios or prerequisites like wallet balance, but overall is sufficiently complete for a straightforward chat tool.

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

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

With 100% schema description coverage, the baseline is 3. The description adds context about model format, discovery tool, and pricing, going beyond the schema's parameter descriptions, earning a higher score.

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 ('Send a message to 200+ AI models via Spraay x402 Gateway') and mentions it returns a completion. It references spraay_models for discovery, distinguishing the lookup tool, but does not explicitly differentiate from other AI chat tools like spraay_bittensor_chat_completions or spraay_compute_text_inference.

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 advises to use spraay_models to discover model IDs, providing some pre-usage guidance. However, it lacks explicit when-to-use or when-not-to-use directives relative to sibling tools, leaving the agent to infer appropriate context.

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

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

The description claims the tool 'analyzes' on-chain activity (implying read-only), but annotations set readOnlyHint=false, indicating it is not read-only. This contradiction undermines 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 three sentences, front-loading the purpose, and includes key details like cost and output types. No wasted words.

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

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

Given the presence of an output schema (mentioned), the description covers return value types and cost. Minor gap: no mention of prerequisites (e.g., address must be on-chain), but overall sufficient for a single-parameter tool.

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

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

Schema coverage is 100%, and the description does not add meaning beyond what the schema provides for the single parameter. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: AI-powered wallet classification with risk scoring, listing specific classification types and outputs. It distinguishes itself from siblings like spraay_classify_tx (transaction classification) and other wallet-related 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 provides context (cost of $0.008 USDC) and what the tool does, but does not explicitly state when to use vs alternatives or when not to use. This leaves room for improvement in guiding agent selection.

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 readOnlyHint and destructiveHint, but the description adds crucial cost information ($0.008 USDC) and states it's AI-powered. It does not contradict annotations.

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

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

Two sentences, front-loaded with purpose and key actions, no wasted words. Includes returns and cost in second sentence.

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

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

Given the output schema exists and parameter count is 1, the description covers purpose, returns, and cost adequately. It is complete for a classification tool.

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

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

Schema coverage is 100% with a single parameter 'hash' described in the schema. The description adds minimal extra meaning beyond stating 'transaction hash to classify'.

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 classifies transactions with risk scoring, specifying it handles Base transactions. It distinguishes from siblings like spraay_classify_address and spraay_contract_read by focusing on transaction hashes and decoded parameters.

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 when transaction classification and risk scoring are needed, but does not explicitly state when to use or avoid this tool versus alternatives like spraay_classify_address or spraay_contract_read.

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

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

Adds cost and discount details beyond annotations, but does not disclose return value (output schema exists), atomicity, or failure modes. Annotations (openWorldHint, readOnlyHint=false) are not contradicted.

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

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

Two sentences, front-loaded with key info (batch size, discount, mix types, cost). 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?

Covers core purpose and payment, but lacks workflow details (e.g., submission returns job IDs, execution status). Output schema may fill gaps, but description could be more complete.

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

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

Schema coverage is 100%, and description only repeats job types and count already in schema. No additional meaning provided beyond what schema offers.

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

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

Description clearly states verb 'submit' and resource 'batch compute jobs', specifies scope (up to 50 jobs, mixed types), and differentiates from sibling single-job compute 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?

Mentions cost savings and discount, implying use for batching multiple jobs. Does not explicitly state when not to use but sibling context provides alternatives. Clear but not exhaustive.

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 non-destructive behavior (destructiveHint=false, readOnlyHint=false). The description adds valuable context: cost ($0.005 USDC) and that it uses 'Spraay Compute', which implies a paid service. This goes beyond what annotations provide.

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

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

Two sentences that efficiently convey the core action, use cases, and cost. No unnecessary words; front-loaded with the primary purpose.

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

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

For a tool with two parameters and an output schema, the description covers what it does, why it's used, and cost. It could mention the output format (e.g., vector array) but the output schema likely handles that. Overall, it is complete enough for agent selection.

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 add further meaning beyond what the schema already describes (input string/array, model default). Baseline 3 is appropriate.

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

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

The description clearly states the tool generates text embeddings and lists use cases (RAG, semantic search, clustering). However, it does not explicitly differentiate from sibling tools like spraay_bittensor_embeddings, which likely serve a similar purpose.

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

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

The description mentions typical use cases (RAG, semantic search, clustering), implying when to use it, but provides no guidance on when not to use it or alternatives (e.g., bittensor_embeddings).

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 and openWorldHint=true. The description adds 'FREE — no x402 payment required' and 'Returns price breakdown per job', which are useful behavioral traits beyond the annotations.

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

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

Two sentences, essential info front-loaded, no wasted words. Perfectly concise.

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?

Tool is simple with one parameter, schema covers everything, output schema exists. Description covers purpose, return value, and cost. Could be slightly more specific about the breakdown format, but output schema fills that gap.

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

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

Schema coverage is 100% with descriptions for jobs, type, and model. The description repeats 'per job' but does not add additional meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

Description clearly states the tool estimates compute cost and returns a price breakdown per job. It uses specific verb 'Estimate' and resource 'compute cost', and distinguishes itself from similar tools like spraay_compute_batch (execution) by noting 'before committing'.

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?

Description implies use for upfront cost estimation and highlights it's free (no x402 payment). However, it does not explicitly exclude execution tools or mention when not to use it, but the context is clear for a simple estimate tool.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds value by disclosing the cost per call, which is behavioral information not in annotations. It also confirms read-only nature. There is no contradiction or missing critical behavioral context.

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

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

The description is concise (three sentences), front-loads the purpose, and contains no redundant information. Every sentence earns its place.

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

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

Given the tool's simplicity (1 parameter, output schema exists), the description covers purpose and cost but lacks clarity on what the 'id' parameter refers to. The schema description is uninformative, and the description does not compensate, leaving ambiguity about the input's meaning.

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 minimal parameter guidance ('Pass the listed fields directly as typed arguments'), but does not explain what the 'id' parameter represents or provide meaningful semantics beyond the schema's vague 'id parameter' description.

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 ('Check remaining compute credit balance, tier, discount, and usage stats'), using specific verbs and listing all relevant resources. It effectively distinguishes from sibling tools like spraay_compute_futures_deposit, spraay_compute_futures_history, etc., by specifying the exact information returned.

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 important usage context: it costs $0.001 USDC per call and is read-only. It also instructs to pass fields as typed arguments. However, it does not explicitly compare to sibling tools or state when to use this tool over alternatives like spraay_compute_futures_history.

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

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

Annotations already indicate a write operation (readOnlyHint=false) and non-destructive. The description adds the cost per call, which is valuable. However, it fails to disclose important behaviors like failure modes, authorization requirements, or interaction with existing account balances.

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

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

Two concise sentences with no redundancy. The description is front-loaded with purpose and cost, making it easy to parse.

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

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

Given the presence of an output schema and annotations, the description covers purpose and cost adequately. It mentions opening an account, which is key context. Missing details on multi-deposit behavior and error handling, but overall sufficient for a focused deposit tool.

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

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

Schema description coverage is 100%, albeit with minimal descriptions ('amount parameter'). The description adds no further semantic information beyond stating to provide typed arguments. Baseline score of 3 is appropriate for high coverage.

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

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

The description clearly states the action ('Deposit USDC') and the purpose ('open a prepaid compute credit account'), effectively distinguishing it from sibling tools like refund or balance. However, it does not explicitly differentiate among the compute futures siblings.

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

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

The description provides a cost hint ($0.01 per call) which helps in usage decisions, but it lacks explicit guidance on when to use this tool versus alternatives or prerequisites. The agent must infer context from the tool's name and siblings.

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 readOnlyHint=false and openWorldHint=true. The description adds transparency by disclosing that the call costs $0.001 USDC and deducts from prepaid balance, which is critical for a write operation affecting finances. However, it does not describe potential errors (e.g., insufficient funds), return value format (though output schema exists separately), or side effects beyond the deduction.

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: first states purpose and cost, second instructs to provide arguments. It is somewhat concise but lacks structure; no paragraphs or bullet points. Could be improved by front-loading the essential cost info, which it does, but missing important details like parameter description or usage 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's complexity (5 params, write operation with financial impact, existence of output schema), the description is insufficient. It does not explain what 'futures' means, how the compute job works, how to use the parameters effectively, or what the return value indicates. The presence of an output schema mitigates this slightly, but the description should provide more context for the 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 has 100% coverage but all parameter descriptions are tautological (e.g., 'type parameter'). The description only says 'Provide the listed fields as typed arguments,' which adds no meaning beyond the schema. For a tool with 5 parameters (including non-obvious ones like 'messages' vs 'prompt'), the description should explain the role of each field, especially since the schema descriptions are unhelpful.

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 'Run a compute job and deduct cost from the prepaid balance,' which clearly indicates the action (run compute) and the resource affected (prepaid balance). It also mentions cost per call. However, it does not explicitly differentiate this tool from other compute-related siblings like spraay_compute_batch or spraay_compute_text_inference, so the purpose is clear but not fully 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 provides no explicit guidance on when to use this tool versus alternatives. It mentions cost deduction and that the user should provide fields as arguments, but does not specify prerequisites (e.g., sufficient balance) or conditions (e.g., when to choose this over spraay_compute_estimate). No exclusions or alternative tool references 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?

Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds value by stating the cost ($0.002 per call) and clarifying it returns a 'Full usage ledger', which is useful context beyond annotations.

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

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

The description is short (3 sentences) and front-loaded with the primary purpose. However, it could be more structured with clear sections. It is concise but omits potentially important details.

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

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

Given that an output schema exists (but not shown in the input), the description is somewhat self-contained. However, it does not mention what the tool returns (e.g., array of ledger entries) or any limitations like pagination. The cost and read-only flag are helpful, but more completeness would improve the agent's understanding.

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% but only provides trivial descriptions ('id parameter', 'limit parameter'). The tool description does not clarify the meaning or expected values of 'id' (e.g., what ID is required) or 'limit' (e.g., max records). The instruction 'Pass the listed fields directly as typed arguments' adds no semantic 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 'Full usage ledger' and 'Read-only', indicating it retrieves a complete history of compute futures usage. The name 'compute_futures_history' aligns with this purpose, and it is distinct from siblings like 'compute_futures_balance' and 'compute_futures_execute'.

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

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

The description mentions cost and read-only nature but lacks explicit guidance on when to use this tool versus alternatives. It does not address scenarios where other history or ledger tools might be more appropriate.

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

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

Annotations already indicate readOnlyHint=true, and the description redundantly states 'Read-only.' It adds cost information and the param format, which are useful but limited. No additional behavioral traits like auth needed or rate limits are disclosed.

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

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

Three concise sentences, each carrying distinct information: purpose, cost/read-only, and parameter usage. No fluff, efficiently front-loaded.

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

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

Given a simple single-parameter tool with an output schema available, the description covers the essential purpose, cost, and parameter format. It does not explain return values, but that is acceptable due to the output schema's existence.

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 the single parameter with a clear description. The tool description merely restates the same instruction ('Pass any query parameters as a JSON string via the params argument'), adding no 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 description starts with 'Compute futures pricing,' which clearly states the action and resource. It distinguishes from siblings like compute_futures_balance and compute_futures_deposit by focusing on pricing computation, though it doesn't explicitly differentiate.

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 basic usage guidance: cost per call, read-only hint, and how to pass parameters. However, it does not include when to use this tool versus alternatives or any exclusions, leaving the agent to infer context.

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

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

Annotations indicate a write operation (readOnlyHint=false) but not destructive. The description adds cost information ($0.01 USDC per call) and clarifies the refund goes to the original depositor. No contradictions, but the added value beyond annotations is moderate.

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 three short sentences, each adding information. It is front-loaded with the main purpose. Minor improvement could be to combine the cost and argument instructions.

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 refund tool with two parameters and an output schema, the description covers the basic action and cost. However, it does not explain the parameters or what the output contains, relying on the schema and output schema which are present. Adequate but not comprehensive.

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

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

Schema coverage is 100% but parameter descriptions are minimal ('caller parameter' and 'futuresId parameter'). The description says 'Provide the listed fields as typed arguments' but does not explain the meaning of the parameters or how they should be used, providing little additional 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 the action 'Refund unused compute credit balance to the original depositor', using a specific verb and resource, and it distinguishes from sibling tools like spraay_compute_futures_deposit and spraay_compute_futures_balance.

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

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

The description mentions the cost per call but does not provide any guidance on when to use this tool versus alternatives, nor does it specify prerequisites or conditions for use. It lacks explicit when-to-use or when-not-to-use instructions.

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

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

Annotations already indicate non-destructive and open-world behavior. Description adds cost range ($0.02-$0.08 USDC), which is useful but does not detail other behavioral aspects like response time or output format beyond schema.

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

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

Two sentences, front-loaded with the verb 'Generate', and no superfluous words. Efficiently conveys model types, task, and cost.

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

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

Given the presence of an output schema, the description adequately covers purpose, models, and cost. Could mention potential output format implicitly, but overall sufficient for a simple generative tool.

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

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

Schema has 100% description coverage, so baseline is 3. Description does not elaborate on parameter semantics beyond what schema already provides; mentions models in overview but not detailed meaning.

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

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

Description explicitly states 'Generate images via Spraay Compute' and lists supported models (FLUX Schnell, FLUX Dev, SDXL) and the text-to-image task, making the purpose clear and distinguishable from sibling tools like text inference or embeddings.

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

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

No guidance on when to use this tool versus alternative image generation or other compute tools. Missing context about preferred scenarios, user prerequisites, or comparison with siblings.

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 read-only (via annotations), adding cost and safety context. The grouping behavior is described, providing clarity beyond the readOnlyHint annotation.

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

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

Two concise sentences with key information front-loaded: listing, pricing, grouping, and cost. No wasted words.

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

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

Given an output schema exists, the description covers purpose, output organization, and cost. It does not mention pagination or freshness, but for a simple list endpoint, it is adequate.

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, and schema coverage is 100%. Description adds no parameter-level detail since none are needed; baseline 3 applies due to high coverage.

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

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

Clearly states it lists all available compute models with pricing and capabilities, grouped by type. Distinguishes from sibling tools like spraay_gpu_models or spraay_bittensor_models by noting free access and comprehensive grouping.

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 mentions 'FREE — no x402 payment required,' indicating low-cost or free usage. However, lacks explicit comparison to alternative model-listing tools or guidance on when to use this versus other sibling tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds value beyond these by noting the cost ($0.001 USDC) and the polling nature, which implies idempotency and no side effects. 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, each adding distinct value: purpose, use case, and cost. No redundant or vague language; all sentences earn their place.

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

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

For a simple polling tool with one parameter and an output schema, the description covers purpose, use cases, and cost. It does not explain polling behavior (e.g., retry logic) or error handling, but the output schema likely provides return format details. Adequately complete for a low-complexity tool.

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

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

With 100% schema description coverage, the parameter 'jobId' is already well-documented in the schema as 'Job ID or prediction ID returned from a compute request'. The description adds only marginal context by linking the parameter to the use cases (video generation, batch jobs), which is helpful but not essential.

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 polls async compute job status and specifies it is for video generation and batch jobs that return 'processing'. This distinguishes it from sibling tools like spraay_compute_video_generation (which likely triggers jobs) and spraay_compute_batch (batch execution). The verb 'poll' and resource 'status' are 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 explicitly says 'Use for video generation and batch jobs that return processing', providing clear context for when to use this tool. It does not mention when not to use it or list alternatives, but the provided use cases are sufficient guidance for the intended scenario.

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 transparency by disclosing the cost of $0.02 USDC, which is a behavioral trait beyond the annotations. However, it does not discuss potential side effects like authentication requirements or data storage.

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 extremely concise with two sentences, front-loading the purpose and cost. Every word adds value with no redundancy.

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

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

For a straightforward speech-to-text tool with an output schema, the description covers the core functionality and cost. Some details like file size limits or supported languages are omitted, but overall it is sufficiently complete.

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

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

The input schema has 100% description coverage, and the tool's description adds minimal additional context about parameters beyond stating 'audio from a URL'. The schema already documents 'model', 'language', and 'audio_url' with descriptions.

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

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

The description clearly specifies the verb 'transcribe', the resource 'audio from a URL', and the model 'Whisper'. It distinctly sets this tool apart from its sibling 'spraay_compute_tts' which performs text-to-speech.

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

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

The description states what the tool does but does not provide explicit guidance on when to use it versus alternatives, nor does it mention when not to use it. The cost is noted but no usage boundaries 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?

Adds cost and provider details beyond annotations. Annotations already indicate non-read-only and non-destructive, but description provides cost range and model count, which aids decision-making.

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

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

Two sentences, front-loaded with the main action, no wasted words. Efficient and clear.

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

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

Covers main purpose, model sources, and cost. Output schema exists so return details not needed. Could mention error handling or rate limits but not essential for this moderate-complexity tool.

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

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

Schema coverage is 100%, so baseline 3. Description adds context on cost variation by model but does not elaborate on parameter specifics beyond schema.

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

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

Clearly states the tool runs LLM text inference, specifies model sources and cost range. Distinguishes from sibling tools like image generation, embeddings, etc.

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

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

Implied use for text inference but lacks explicit guidance on when to use over similar tools like spraay_chat or spraay_bittensor_chat_completions. No exclusions or alternatives mentioned.

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

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

Discloses cost range ($0.03-$0.05 USDC) and references Replicate TTS models, but does not describe output format, latency, or idempotency behavior. Annotations already indicate non-read-only, so description adds limited behavioral context.

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

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

Three sentences covering purpose, action, and cost. No wasted words, but could be slightly more structured. Front-loaded with the core 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?

Lacks information about output format (audio URL or binary?), prerequisites, and how model selection affects results. Despite having an output schema, the description should at least hint at the output nature.

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

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

Schema description coverage is 100%, with descriptions for text, model, and language. The tool description adds no additional meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states it converts text to speech via Spraay Compute, distinguishing it from speech-to-text and other compute tools. The verb 'convert' and resource 'text-to-speech' are 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?

No guidance on when to use this tool versus alternatives or when not to use it. No mention of model selection context or prerequisites.

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

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

Adds behavioral info not in annotations: async operation, polling, cost. Annotations provide no extra context, so description adds useful transparency beyond them.

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

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

Three efficient sentences with front-loaded purpose. Every sentence adds value: action, models, async/cost. No redundancy.

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

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

With output schema present, description covers async polling and cost. Mentions sibling tool for status. Lacks potential details like timeout, but complete enough for typical 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 has 100% coverage for 3 params. Description mentions model names but doesn't add meaning beyond schema's parameter descriptions. 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?

Description clearly states 'Generate video from text' and lists specific models (MiniMax Video 01, Wan 2.1). Differentiates from siblings like spraay_compute_image_generation by specifying video generation.

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

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

Describes async nature and polling requirement ('poll spraay_compute_status for results') and gives cost range. Implicitly indicates when to use (text-to-video) but no explicit exclusions 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?

The description says 'Read contract' implying a read-only operation, but annotations have readOnlyHint=false, indicating the tool may have side effects. This is a contradiction. Additionally, while cost is disclosed, the behavioral inconsistency is misleading.

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 short and front-loaded with the purpose and cost. No unnecessary words, though more detail could fit without harming conciseness.

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

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

Even with an output schema, the description lacks context about what contract reading entails (e.g., which chain, method meaning). The minimal text leaves ambiguity for an agent to correctly select and invoke this tool.

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

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

Schema descriptions are minimal ('args parameter', 'chain parameter') and the description adds only 'Provide the listed fields as typed arguments', which does not clarify what each parameter represents. Despite 100% schema coverage, the descriptions are uninformative.

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 (Read contract) and distinguishes from sibling spraay_contract_write. However, it does not differentiate from spraay_explain_contract, which may also involve reading contract data. The verb+resource is 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?

No guidance on when to use this tool versus alternatives like spraay_explain_contract or spraay_rpc_call. The instruction to 'Provide the listed fields as typed arguments' is basic but does not help with context or exclusions.

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

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

Annotations indicate readOnlyHint=false (write operation) and openWorldHint=true, plus description adds a cost of $0.01 USDC per call. However, it does not disclose side effects like gas costs on certain chains, required auth, or irreversible changes. The minimal addition beyond annotations merits a 3.

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 brief sentences that include the core action, cost, and a parameter instruction. No fluff, but could be organized better (e.g., listing parameters in the description itself).

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 5 parameters, an output schema, and many sibling tools, the description lacks crucial context. It does not clarify what 'write' means (e.g., on-chain transaction vs internal record), how the output schema relates, or any dependencies like wallet funding. The description is too sparse for an agent to reliably 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 descriptions are tautological (e.g., 'args parameter', 'chain parameter') and the description only says to provide fields as typed arguments, adding no meaning. For 5 parameters with a write operation, more semantic detail (e.g., what 'args' entails, chain ID format) is needed.

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

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

The description states 'Write contract' which is a verb+resource pairing that distinguishes it from the sibling spraay_contract_read. However, it does not specify what kind of contract (smart contract, legal contract, etc.) or the exact scope of writing (e.g., deploying or invoking).

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

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

No usage guidelines are provided. The description does not indicate when to use this tool over alternatives, such as when to use spraay_contract_read vs write. There is no mention of prerequisites, context, or exclusions.

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

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

Annotations indicate destructive and idempotent behavior; the description adds context by stating data persists in Supabase and costs $0.001 USDC, which aligns with the destructive hint and provides extra 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 three concise sentences: action, effect, and cost. No unnecessary words, front-loaded with the core purpose.

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

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

For a simple, single-parameter tool with an output schema, the description covers purpose, effect, data persistence, and cost, making it complete for an AI 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?

With 100% schema coverage and one parameter (`jobId`), the description does not add more meaning beyond what the schema already provides (e.g., format example). The cost mention is tangential.

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 ('Cancel a scheduled job by ID') and the effect ('Stops future executions'), distinguishing it from cron creation and listing 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 implies when to use (to stop a scheduled job) but does not explicitly exclude other scenarios or mention alternative tools like `spraay_cron_create` or `spraay_cron_list`.

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

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

The description adds behavioral context beyond annotations: it states 'Data persists in Supabase' and 'Costs $0.005 USDC.' Annotations indicate readOnlyHint=false (write), idempotentHint=false, and destructiveHint=false. The description aligns with these and provides useful cost and persistence information. 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?

Four sentences, all substantive. Front-loaded with purpose, then cron support, persistence, and cost. Every sentence earns its place with relevant information. No fluff or repetition.

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

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

Given 4 parameters with nested objects and the presence of an output schema (indicated true), the description covers key aspects: purpose, cron standard, persistence, and cost. It doesn't detail error conditions or how to retrieve the cron ID for cancellation, but these are secondary. Overall, complete enough for effective use.

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

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

Schema coverage is 100% (all parameters have descriptions). The description adds value by noting 'Supports standard 5-part cron expressions' and clarifying that the payload format matches the action's direct API call. This provides meaning beyond the schema, but the schema already adequately describes each parameter.

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

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

The description clearly states the tool's purpose: 'Create a scheduled job for recurring payments, DCA strategies, reminders, or any gateway action.' It specifies the resource (scheduled job) and provides concrete examples. It also mentions support for standard 5-part cron expressions. This distinguishes it from sibling tools like spraay_cron_cancel and spraay_cron_list.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. It lacks information about prerequisites, when not to use, or context for choosing this over other cron-related tools. The existence of siblings like spraay_cron_cancel and spraay_cron_list is implied but not addressed.

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

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

Annotations already mark it as readOnlyHint and openWorldHint. The description adds useful behavioral context: data persistence in Supabase and cost ($0.001 USDC). 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 efficient sentences: first covers core functionality, second adds persistence and cost. No fluff, front-loaded.

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

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

For a simple listing tool with output schema and annotations, the description covers purpose, filters, data persistence, and cost. No missing essential 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?

Schema coverage is 100%, so baseline 3. The description mentions optional filters but adds no additional meaning beyond what the schema's parameter descriptions already provide.

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 'list' and the resource 'scheduled jobs', with optional filters. It distinguishes this tool from other cron tools like create and cancel.

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

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

The description does not explicitly state when to use this tool versus alternatives. It implies usage for listing jobs, but lacks guidance on when not to use it or context with siblings.

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 and openWorldHint. The description adds the cost per call ($0.008 USDC) and a note to pass fields as typed arguments, which is marginally helpful but does not significantly expand on behavioral traits beyond annotations.

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

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

The description is very concise with three sentences covering purpose, cost, and usage instruction. It is front-loaded with the key phrase 'DeFi positions'. Every sentence adds value, though it could be slightly more detailed without becoming verbose.

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

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

Given the presence of an output schema and high schema coverage, the description covers essential aspects (purpose, cost, read-only, argument passing). It does not mention that address is required, but the schema already specifies that. Reasonably complete for this 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%, so parameters are already documented. The description only says 'Pass the listed fields directly as typed arguments', adding no new meaning 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?

The description states 'DeFi positions', which indicates the resource but lacks specificity about what type of positions (e.g., liquidity, staked). It does not differentiate clearly from sibling tools like spraay_portfolio_tokens or spraay_balances. The verb is implied but not explicit.

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

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

No guidance on when to use this tool versus alternatives such as portfolio tokens or balances. The description mentions cost and read-only nature but provides no context about ideal use cases 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?

Annotations already indicate destructive and idempotent behavior. The description adds value by disclosing data persistence in Supabase, cost ($0.002 USDC), and authorization conditions. 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?

Description is three sentences, front-loaded with the purpose, followed by authorization rules and cost/persistence. No unnecessary words, efficient structure.

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

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

Given the simple tool with two parameters, full schema coverage, annotations, and known output schema, the description covers purpose, authorization, persistence, and cost. It could mention irreversibility or error conditions but annotations handle some of that.

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 essentially repeats the parameter descriptions from the schema (e.g., caller must be depositor or arbiter for funded escrows). No additional meaning is provided beyond the schema.

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

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

The description clearly states it cancels an escrow, specifies conditions based on funding state (unfunded vs funded), and who can cancel. This distinguishes it from sibling tools like create, fund, get, list, and release.

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 cancel an escrow) and who can call it under different states. However, it does not explicitly mention when not to use or compare to alternatives like releasing funds.

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

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

Annotations are minimal (no idempotent, readOnlyHint false). The description adds valuable behavioral context: 'Funds are held until release conditions are met', 'Data persists in Supabase', and 'Costs $0.008 USDC'. It also mentions return values. No contradiction with annotations.

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

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

Three sentences, front-loaded with the core purpose. No wasted words. Efficient and clear.

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

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

Given the tool's complexity (7 parameters, 4 required, Blockchain interaction), the description covers purpose, behavior, persistence, cost, and return type. It could mention prerequisites (e.g., wallet funding) but is largely complete. An output schema exists to describe return structure.

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 mentions 'optional milestones, arbiter, and expiry' but does not add detailed parameter semantics beyond what the schema already provides. Each parameter is well-documented in the schema itself.

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

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

Description clearly states it creates a conditional escrow, specifies optional features (milestones, arbiter, expiry), and names the blockchain (Base). The verb 'Create' plus resource 'escrow' with qualifiers like 'conditional' and 'optional' make the purpose specific and distinguishable from sibling tools like escrow_fund, escrow_release, etc.

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

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

The description implies when to use by stating it creates an escrow, which contrasts with siblings that fund, release, cancel, or get/list escrows. However, it lacks explicit 'when to use' or 'when not to use' statements. The context of sibling names provides sufficient differentiation.

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 data persists in Supabase and costs $0.002 USDC, which are important behavioral traits beyond annotations. Annotations only provide readOnlyHint; description adds cost and persistence context.

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

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

Three concise sentences, each serving a purpose: purpose, precondition, and additional context (persistence, cost). No unnecessary information.

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

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

Covers purpose, precondition, persistence, and cost. With output schema existing, return values need not be explained. Complete for a simple state-change tool.

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

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

Schema coverage is 100% and schema already describes escrowId with an example. Description does not add extra parameter semantics beyond what's in the schema.

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

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

Clear verb 'Mark as funded' and purpose stated. Distinguishes from escrow siblings (create, cancel, release) by specifying the specific status change from 'created' to 'funded'.

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