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

Without annotations, the description carries the full burden. It discloses the primary side effect (release of escrow) and the active-trade precondition. It does not address irreversibility in detail, but the word 'cancel' and the escrow release provide adequate transparency for a simple cancellation action.

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 one sentence, two clauses, with no extraneous words. It front-loads the action and the key condition, making it highly concise and well-structured.

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

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

Given the tool's simplicity (two well-documented parameters, no output schema, no nesting), the description adequately covers the action, the effect on escrow, and the precondition. There is no missing contextual information for an agent to invoke it 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 already provides descriptions for both parameters (tradeId and userId), covering 100% of the schema. The tool description adds no additional parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool cancels an active trade and releases locked escrow. It uses a specific verb and resource, and it is clearly distinct from sibling tools like list_trades or get_offer.

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 notes that cancellation is only possible while the trade is active, providing clear context for when to use it. However, it does not mention alternatives or explicitly exclude other states, so it stops short of full guidance.

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

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

With no annotations provided, the description carries the burden of disclosing side effects and behavior. It only states 'Check the status', which implies a read-only operation but doesn't explicitly confirm no side effects, nor does it describe what happens for invalid IDs, whether the status is blocking, or what fields are returned. The absence of output schema makes this gap significant.

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

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

The description is a single sentence of 8 words, extremely concise and free of redundancy. It gets straight to the point with no filler.

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

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

The tool is simple with one parameter and no output schema. However, the description does not explain the return format, possible statuses, or behavior on errors. While low complexity reduces the need for extensive detail, the lack of any response information leaves the agent uncertain about what to expect.

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

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

The input schema already provides a description for the single parameter, approvalRequestId, with a pointer to request_agent_transaction. The tool description adds no further detail about parameters, but since schema coverage is 100%, the baseline of 3 applies.

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

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

The description uses a specific verb ('Check') and resource ('status of a pending agent transaction approval'), clearly distinguishing it from sibling status tools like get_deposit_status or get_kyc_status. It states exactly what the tool does.

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 relative to alternatives. It does not mention that this should be used after requesting a transaction or before executing it, nor does it rule out other status checks. Only the input schema hints at its place in the workflow via the parameter description referencing request_agent_transaction, but the description itself lacks usage context.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects. It explicitly states 'The creator locks totalAmount in escrow,' which is a critical behavioral consequence for an agent to understand before invocation. However, it does not mention other potential traits such as response format, reversibility, or permission requirements, so it is not fully transparent.

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 short sentences that front-load the core verb and resource, followed by a key consequence. Every word contributes meaning; there is no redundancy or filler.

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

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

Despite having 16 parameters and no output schema, the description provides only the basic request and one side effect. It does not explain what happens after creation, how to interpret the response, or any prerequisites, leaving substantial context gaps for such a complex financial operation.

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

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

Schema coverage is 100%, so the description is not required to explain each parameter. The only addition—'locks totalAmount in escrow'—merely repeats the schema description for totalAmount ('Total leveraged amount locked in escrow'), adding no new semantic value beyond the structured data.

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 'Create a prediction market offer' with a specific verb and resource, clearly distinguishing it from sibling operations like update_offer, delete_offer, and list_offers. It also appends a unique behavioral detail about escrow locking, reinforcing its purpose as a creation action with financial commitment.

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 creating an offer through the imperative verb 'Create', but it does not explicitly state when to prefer this tool over alternatives or mention any exclusions/prerequisites. The escrow-locking note hints at a condition (locking funds) but does not provide explicit guidance versus 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?

With no annotations provided, the description carries the full burden. It explicitly discloses destructive behavior ('Permanently delete'), ownership requirement ('your own offer'), and an important business rule ('Blocked if the offer has active trades'). This goes beyond minimal requirements, though it could be richer (e.g., effects on linked data).

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

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

One sentence, highly compact, front-loaded with the action and key qualifiers. No fluff or redundant 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?

The tool has only 2 params and no output schema, so the description is largely adequate. It covers the essential behavior and a key blocking condition. It does not mention return values or other failure modes, but these are not critical for a simple delete operation. Overall, it is sufficiently complete for an agent to select and invoke correctly.

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

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

Since the input schema already provides 100% parameter descriptions, the baseline is 3. The description does not add new parameter-level detail; 'your own offer' is already reflected in the schema's userId description. No additional context is provided.

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 and resource: 'delete your own offer.' It also specifies permanence ('Permanently') and a condition ('Blocked if the offer has active trades'), which distinguishes it from related tools like delist_offer.

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 this tool: for permanent deletion of one's own offer, with the caveat that it cannot be used when trades are active. However, it does not explicitly mention alternatives or exclusions, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses the key behavioral consequence of releasing locked escrow, which goes beyond the schema. However, it does not mention reversibility, permissions, or what happens to the offer after deactivation.

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, efficient sentence of 12 words. It front-loads the action and includes the key side effect with no filler.

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

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

For a tool with one required parameter and no output schema, the description covers the essential action and a critical consequence (escrow release). It could be improved by mentioning reversibility or return value, but it is generally adequate for a simple operation.

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

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

Schema description coverage is 100%, with both parameters already documented. The description adds little beyond a general sense of ownership ('your own offer'), which is already implied by the schema's 'Owner's external user ID'. Thus 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 delists (deactivates) the user's own offer and releases escrow, using a specific verb and resource. It implicitly distinguishes from 'delete_offer' by using 'deactivate' and restricting to 'your own offer'.

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 update_offer or delete_offer. The description only states the action itself, leaving the agent to infer the appropriate context, with no exclusions or alternative suggestions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states that the input message is returned back to the caller, implying a pure echo with no side effects or hidden requirements. It does not detail the exact return format or error handling, but for a trivial echo tool this is sufficient.

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

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

The description is a single sentence that is concise and to the point, with no redundant or unnecessary content. Every word contributes to the meaning.

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

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

For a tool with one fully-documented parameter and no side effects, the description is complete. The return value is obvious from the description, and no output schema is needed. There are no hidden prerequisites or error cases that would require additional explanation.

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

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

Schema description coverage is 100%, and the single parameter 'message' is fully described as 'The message to echo'. The description adds no semantic value beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'echoes' and resource 'input message', clearly stating what the tool does. It distinguishes itself from the sibling trading tools by being a simple utility that returns the input, so there is no ambiguity.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, but the purpose is self-evident given the tool name and the context of sibling tools. A hint about using it for testing connectivity or debugging would improve the guidance.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It mentions escrow locking ('locks the same totalAmount in escrow') but omits side effects like trade creation, offer state changes, and financial implications. The statement is vague and doesn't fully convey the operation's impact.

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

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

The description is a single, front-loaded sentence with no filler. It states the primary action and a key behavioral trait efficiently, making it easy to scan.

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 9 parameters, no annotations, and no output schema, the description is underspecified. It doesn't explain parameter roles beyond the schema, the meaning of 'same totalAmount', or the expected outcome/response, leaving significant gaps for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no extra parameter-level meaning; it uses 'totalAmount' without mapping to the 'amount' parameter or clarifying the relationship between buyerProfileId/sellerProfileId and userId.

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

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

The description uses a specific verb 'Engage' with a clear resource ('an open offer') and explains it as 'trade against', making the core function unambiguous. It doesn't explicitly contrast with sibling tools like create_offer or cancel_trade, but the action is distinct enough to 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?

No explicit guidance on when to use this tool versus alternatives. The description only states what the tool does and mentions escrow locking, but does not cover prerequisites, selection criteria, or when to prefer it over related trade operations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'estimate fees' with no mention of side effects, whether it is read-only, how fees are calculated, or if it makes any external calls. The minimal wording leaves safety and operational behavior ambiguous.

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

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

The description is a single, front-loaded sentence with no wasted words. It conveys the essential action and timing in a compact form.

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

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

The tool is simple, with no output schema and no annotations, and the description only says it estimates fees. It does not disclose what the fee estimate consists of (e.g., currency, breakdown) or any caveats, which would be valuable for an agent deciding whether to proceed. It is minimally complete but leaves 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 description coverage is 100%, with each parameter having a clear description (e.g., 'Source currency code (e.g. USD)'). The tool description adds no parameter-level semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly uses the specific verb 'estimate' and names the resource 'fees for a currency swap,' which differentiates it from executing tools like swap_currency and rate tools like get_exchange_rate. It precisely states what the tool does: computes fee estimates, not rates or actual swaps.

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

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

The phrase 'before executing' provides clear context that this tool should be used prior to swap_currency. However, it does not explicitly mention alternative tools or when not to use it, so it stops short of a full usage-guide.

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

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

No annotations are provided, so the description carries the full burden. It says 'execute a transaction' but does not disclose side effects, irreversibility, idempotency, or whether it can be called multiple times. It also lacks details on failure modes or the need for valid approval credentials.

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, concise sentence that conveys the core purpose without unnecessary words. It is appropriately sized for a tool with simple parameters.

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 executes a transaction and has no output schema or annotations, the description is too sparse to be complete. It does not explain the approval workflow, how the request ID and token are obtained, or what happens upon execution. This is a significant gap for a mutating 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?

The input schema already documents both parameters (approvalRequestId and executionToken) with clear descriptions. The description adds no additional meaning beyond the schema, so the baseline of 3 applies due to high schema coverage.

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

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

The description clearly states the tool's action ('Execute') and resource ('a transaction') with a condition ('after it has been approved'). This distinguishes it from other transaction tools like transfer_tokens or swap_currency, which are not approval-based.

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

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

The phrase 'after it has been approved' implies the tool should be used only after an approval step, but it does not explicitly mention when not to use it or name alternative tools. There is clear context but no 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?

No annotations are provided, so the description must carry the burden of explaining behavior. It only states 'look up,' which implies a read operation, but it does not disclose permissions, return format, error behavior, or any side effects. This is a minimal disclosure.

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, focused sentence with no unnecessary words. It is appropriately sized for a simple lookup tool and front-loads 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?

Given the low complexity (one parameter, no output schema), the description conveys the essential purpose, but it lacks details about return values, error conditions, or prerequisites. It is adequate but not fully complete.

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

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

Schema description coverage is 100%, with the parameter described as 'Target user ID or email address.' The tool description does not add any further meaning to the parameter beyond what the schema already provides, so baseline 3 applies.

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

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

The description clearly states the action ('look up') and the resource ('another user's agent configuration'). It is specific and distinguishes this tool from siblings like get_my_profile or get_server_info, as it targets another user's agent configuration.

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 guidance on when to use this tool versus alternatives. The phrase 'another user's' implies it is not for your own config, but no explicit context, exclusions, or alternative tools 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?

With no annotations provided, the description carries the full burden for behavioral disclosure. The word 'Get' implies a read-only operation, but the description does not explicitly confirm no side effects, nor does it mention defaults for unspecified parameters or return format. This is adequate but minimal.

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

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

The description is a single, front-loaded sentence that directly states the action and scope. It contains zero filler and is highly efficient.

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

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

For a simple two-parameter query tool, the description covers the core intent. However, it lacks a note on return format (e.g., whether both HBAR and HTS tokens are included) and does not differentiate from the similar-sounding 'get_escrow_balances'. These are minor gaps given the tool's simplicity.

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

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

Schema description coverage is 100%, so the schema already documents both 'tokenId' and 'accountId'. The description adds little beyond the schema—'all tokens or a specific token' maps to tokenId but provides no syntax or format details. 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 purpose: 'Get Hedera account balances for all tokens or a specific token.' The verb 'Get' and resource 'Hedera account balances' are specific, and the scope is unambiguous. It also implicitly distinguishes itself from sibling tool 'get_escrow_balances' by focusing on account balances.

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

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

The description implies usage: use this tool to query account balances. However, it does not explicitly provide when-not-to-use guidance or mention alternatives such as 'get_escrow_balances'. Since sibling tools exist and are not referenced, the guidance is limited.

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

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

With no annotations provided, the description relies on the verb 'Get' to imply a read-only operation. It does not disclose additional behavioral traits such as authentication requirements, error behavior, or what the status response contains.

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

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

The description is a single short sentence that is front-loaded with the action and resource. Every word is necessary; there is no verbosity.

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 getter with full schema parameter descriptions and no output schema, the description adequately states the tool's purpose and key identifier. However, it could benefit from mentioning what statuses are returned or how to identify a deposit transfer ID.

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

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

The input schema provides full descriptions for both parameters (100% coverage), so the baseline is 3. The description adds minimal semantic value by specifying 'fiat deposit', which clarifies the domain of the transfer ID. It does not elaborate on the userId 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 uses the specific verb 'Get' and names the resource 'status of a fiat deposit' with a qualifier 'by transfer ID'. This clearly distinguishes it from sibling tools like get_withdrawal_status and initiate_deposit.

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

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

The description implies it should be used to check a deposit's status using its transfer ID, but does not explicitly state when to use it instead of alternatives like get_withdrawal_status or get_transaction_history. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It only states the action and output structure, with no mention of authentication requirements, rate limits, or side effects. The default userId behavior is mentioned in the schema, not the description.

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 concise sentence that front-loads the verb and resource, with 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?

The tool is simple with one optional parameter and no output schema. The description adequately explains the return value (breakdown with total, available, locked). However, it lacks behavioral or usage context, which is a minor gap for such a straightforward 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%, with userId fully described including its default behavior. The tool description adds no additional parameter semantics beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool gets a user's escrow balance breakdown with specific components (total, available, locked). This distinguishes it from siblings like get_balances (general balances) and get_escrow_history (escrow 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 implies usage for checking escrow balances, but does not explicitly state when to use this tool versus alternatives like get_balances or get_escrow_history. No exclusions or alternative guidance 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It doesn't mention that this is a read-only operation, nor does it describe return format, pagination, authentication needs, or whether 'full' includes pending or historical states. This lack of context leaves the agent without important safety and outcome information.

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

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

A single, well-structured sentence that leads with the action and resource, then enumerates the covered categories. No filler or redundant phrasing. It is concise 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?

For a simple single-parameter tool with no output schema, the description covers the main scope (escrow transaction history) and lists included transaction types. However, it lacks behavioral details like pagination or ordering, and doesn't help disambiguate from the general get_transaction_history. These gaps prevent a perfect score.

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 describes the only parameter (userId) as 'External user ID. Defaults to your own user ID.' with 100% coverage. The description simply says 'a user's' and adds no additional meaning or constraints beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the specific resource 'user's full escrow transaction history' with coverage of locks, releases, wins, losses, and fees. This makes the tool's purpose obvious. However, it doesn't explicitly distinguish it from sibling tools like get_transaction_history or get_escrow_balances, so it stops short of a 5.

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

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

Usage context is implied: use this to retrieve a user's escrow transaction history. There is no explicit guidance on when not to use it or which alternative to choose (e.g., get_transaction_history for general history). The description would benefit from mentioning that get_transaction_history covers non-escrow transactions or that this tool is solely for escrow-related records.

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

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

With no annotations provided, the description must carry the burden of behavioral disclosure. It accurately indicates that the tool returns buy/sell rates (implying a read-only operation), but does not clarify whether rates are real-time, indicative, or how 'current' is defined. This is a modest baseline for a simple getter.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the action and object, making it very 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 tool has only one parameter and no output schema, the description partially covers return values by mentioning buy/sell rates. However, it does not specify the structure of the response or any additional context like rate timing or source. This is adequate but not fully 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 schema covers the sole parameter (currency) with an example format. The description adds no new semantic information beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('current buy/sell exchange rates for a currency'), clearly distinguishing it from sibling tools like swap_currency (which performs conversion) or list_supported_currencies (which lists codes). It precisely conveys what the tool does.

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

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

The description gives no guidance on when to use this tool versus alternatives such as swap_currency or estimate_swap_fees. It simply states what it does without any context for 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?

The description restates the tool's name without adding behavioral context. Since no annotations are provided, it fails to disclose whether the operation is read-only, what the response format looks like, or any authentication requirements.

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

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

The description is a single, focused sentence with no wasted words. It is concise and front-loaded, appropriately sized for a simple getter 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, the description is minimally adequate but lacks details about the return value or potential statuses. Without an output schema or annotations, the agent may not know what to expect beyond the name. More context 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?

The input schema fully describes the sole parameter (userId) with a clear description and default behavior. The description adds no additional parameter semantics, but the high schema coverage justifies a 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 action ('Get') and the resource ('KYC verification status'), which distinguishes it from siblings like initiate_kyc. However, it does not explicitly differentiate itself or mention scope, so it falls short of a 5.

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 such as initiate_kyc. There is no mention of prerequisites, typical use cases, or situations where another tool would 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?

With no annotations provided, the description carries full responsibility for disclosing behavior. It implies a read-only operation through the verb 'Get' and clarifies the resource via 'your API key', but it doesn't mention auth requirements, return format, or whether this is scoped to the current user's key. It's accurate but minimal.

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

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

One crisp sentence that is front-loaded and immediately communicates the tool's purpose. No wasted words.

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

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

For a parameterless read-only tool, the description adequately covers the purpose. It doesn't describe output structure, but for such a simple tool, that's an acceptable gap. The description is complete enough for an agent to decide when to use it.

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

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

The tool has zero parameters, so the description doesn't need to explain parameter meanings. It clearly indicates the tool returns limits and usage, which is sufficient.

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

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

The description uses the specific verb 'Get' with a clear resource ('your API key limits and current usage'), distinguishing it from sibling tools like get_balances or get_my_profile by explicitly focusing on API key limits.

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

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

The description provides no usage context, no guidance on when to use this tool versus alternatives, and no exclusions. It simply states what it does.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It only gives scope ('created by a specific user') and 'all' offers, but does not mention read-only safety, pagination, ordering, filtering aside from offerType, or what happens if no offers exist.

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

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

A single, front-loaded sentence that earns its place. No filler or repetition of schema details.

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

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

For a read-only list tool with two optional, well-described parameters, the description is minimally viable. It lacks an output schema and does not describe the return format or any limitations, so agents may be uncertain about the exact response shape.

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% parameter description coverage: userId includes external ID and default behavior, offerType explains filtering. The tool description adds no extra meaning beyond the schema, so the 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 action (get), resource (offers), and scope (created by a specific user). It distinguishes this from siblings like list_offers (general offer listing) and get_offer (single offer).

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

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

The description makes it clear this tool is for retrieving offers created by a particular user, which implies its niche versus list_offers. However, it does not explicitly state when not to use it or name alternative 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?

With no annotations, the description carries the behavioral disclosure burden. It clearly indicates a read operation via 'Get' and specifies the data it returns, though it does not explicitly state that it is read-only or require authentication. This is adequate for a simple getter.

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

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

The description is a single, front-loaded sentence that avoids extraneous detail. It efficiently conveys both the action and the primary output.

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

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

For a zero-parameter getter with no output schema, the description sufficiently explains the return contents ('user ID, wallets, and account details'). It is complete for the tool's simplicity and aligns with sibling tools that are similarly self-descriptive.

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

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

The tool has zero parameters and the schema is empty, so the description adds no parameter semantics beyond the baseline. The description's mention of included fields ('user ID, wallets, and account details') gives some context about what the returned data contains, satisfying the baseline expectation.

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

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

The description uses a specific verb and resource ('Get your BananaCrystal profile') and lists key contents (user ID, wallets, account details). This clearly distinguishes it from sibling tools like get_my_limits or get_my_offers.

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 alternatives. The purpose is self-evident (retrieving profile info), but no when-to-use or when-not-to-use scenarios are provided, so the guidance is implied at best.

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

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

With no annotations provided, the description bears the full burden of behavioral disclosure. It partially does so by explaining the inclusion logic (user-created trades and trades on owned offers), but it does not mention authentication requirements, rate limits, default behavior for optional parameters, or the return format.

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 conveys the essential scope without wasted words. It is front-loaded with the verb and resource, making it easy to scan.

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

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

Given the low complexity (three optional parameters, no nested objects, no output schema), the description plus full schema coverage is mostly sufficient. It does not describe the return structure, but for a read-only list operation under this sibling set, this is a minor 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?

The input schema already provides descriptions for all three parameters (state, userId, tradeType), achieving 100% schema description coverage. The description adds no additional parameter-level meaning beyond what the schema offers, so the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Get all trades') and the resource scope ('for a user'), explicitly including both trades the user created and trades on offers they own. This distinguishes it from general trade-listing tools like list_trades by focusing on user-specific trades.

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 guidance on when to use this tool versus alternatives such as list_trades or get_trade. There is no mention of exclusion criteria, prerequisites, or context in which this tool is preferred.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It mentions the response includes trade stats and time remaining, which is helpful, but it does not explicitly state the operation is read-only or cover error handling/auth requirements. The verb 'Get' implies safety, but the description adds limited behavioral context beyond that.

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

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

The description is a single sentence of ten words, front-loaded with 'Get full details of a single offer' followed by clarifying content. Every word earns its place, with no redundancy or filler.

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

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

Given the low complexity (one parameter, no output schema, no annotations), the description provides a clear sense of the returned data (trade stats, time remaining) and the scope (single offer). It omits details about error behavior and authentication, but these gaps are partially mitigated by the simplicity of the operation and the schema's parameter description.

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

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

The schema already provides full coverage for the sole parameter 'offerId' with a clear description ('Offer UUID'), so the baseline is 3. The tool description does not add any extra meaning or context to the parameter, so it neither enhances nor detracts from 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 uses the specific verb 'Get' with the resource 'full details of a single offer', clearly distinguishing it from sibling tools like list_offers that return collections. It also specifies content such as 'trade stats and time remaining', making the tool's purpose unmistakable.

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

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

The description implies usage for fetching one offer by ID, but it does not explicitly state when to use this tool instead of alternatives like list_offers or get_my_offers. No exclusions or alternative tool references are provided, so usage guidance relies on inference.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only action by saying 'returns', but it does not disclose what 'basic server information' includes, whether authentication is needed, or what the response structure looks like.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately communicates the tool's core purpose and is appropriately sized for the tool's simplicity.

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

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

For a zero-parameter tool, the description is minimally viable, but it lacks detail about what 'basic server information' includes and does not provide an output schema. Given the lack of annotations, the description could be more complete, though the tool is simple enough that this may be acceptable.

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

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

The tool has zero parameters, so the schema fully covers the parameter space. The description does not need to add parameter details, and the baseline of 4 is appropriate.

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

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

The description clearly identifies the action (returns) and resource (server information). It is not a tautology and is distinct enough from sibling tools, though the word 'basic' is vague and could be more 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 gives no guidance on when to use this tool versus alternatives, and no exclusions or prerequisites are mentioned. It simply states what the tool does without contextual usage direction.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It implies a read-only operation ('Get') and mentions the inclusion of parent offer stats, but it does not describe error behavior, authorization needs, or what 'full details' encompasses. Some transparency is present, but gaps remain.

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

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

The description is a single sentence that is concise, front-loaded with the action, and free of unnecessary words. It effectively communicates the tool's core function and a key differentiating detail.

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

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

Given the tool's low complexity (one parameter, no output schema, no annotations), the description provides sufficient context by stating the resource type and the unique inclusion of parent offer stats. However, the lack of an output schema means the return format is not fully specified, though 'full details' offers a general expectation.

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

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

The input schema already provides 100% coverage for the only parameter (tradeId) with a clear description ('Trade UUID'). The description adds no additional semantic detail about how tradeId is used, so it does not exceed the baseline established by the schema.

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

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

The description states a specific verb ('Get') and resource ('full details of a single trade'), and adds a distinguishing feature ('including the parent offer stats') that separates it from sibling tools like list_trades or get_my_trades. It clearly identifies the tool's purpose and scope.

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

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

The description implies usage when a specific tradeId is known and full details are needed, but it does not explicitly mention when not to use it or direct users to alternatives. Sibling tools like list_trades are not referenced, leaving usage guidance implicit rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read operation via 'Get' but does not explicitly state side-effect-free behavior, pagination details, or whether the history includes all transaction types (e.g., swaps, transfers) or only settled ones. No additional behavioral context is given beyond the action itself.

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, short sentence that front-loads the main verb and resource. It contains no unnecessary words or repetition, making it extremely concise and easy to parse.

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

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

For a simple read tool, the description is minimally adequate, but it lacks contextual completeness. It does not explain how this tool relates to sibling tools like get_my_trades or get_escrow_history, nor does it summarize the transaction types covered (swap, transfer) as revealed by the schema. With no output schema, the description could have clarified what the response contains, but it doesn't.

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 cover 100% of the parameters, providing clear explanations for 'page', 'type', 'limit', and 'direction'. The description only adds the generic phrase 'filtering options,' which does not enrich parameter meaning beyond what the schema already documents. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states the action ('Get') and resource ('your transaction history'), indicating it retrieves the user's own transaction records. This distinguishes it from sibling tools like get_escrow_history and get_my_trades, which cover different types of transaction-related data. The phrase 'with filtering options' implies configurable results, but the core purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, such as using get_escrow_history for escrow transactions or get_my_trades for trade-specific histories. There is no context on typical use cases, prerequisites, or relationships to 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?

No annotations are provided, so the description carries the burden. The verb 'get' implies a read operation, and the schema parameter notes 'Defaults to your own user ID', which adds some behavioral context. However, the description does not disclose output format, possible side effects, or any rate limits or permissions, leaving gaps for a tool with zero annotation coverage.

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

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

The description is a single, concise sentence that conveys the essential purpose without unnecessary words. It is easy to parse and front-loads the key action and object.

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 one-parameter getter, the description is adequate but not complete. It does not explain the return format (e.g., fields like status, amount, timestamps) or provide any context about how to interpret the response, which is a gap given there is no output schema. However, the low complexity and clear purpose keep it at a minimum viable level.

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 userId described as 'External user ID. Defaults to your own user ID.' The description adds no further parameter meaning beyond what the schema already provides, justifying 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 withdrawal requests for a user via Brale' – a specific verb ('get'), resource ('withdrawal requests'), and scope ('for a user'). It distinguishes itself from sibling tools like get_deposit_status and request_withdrawal by naming 'withdrawal' as the focus.

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

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

The description gives a clear indication of when to use this tool (to retrieve withdrawal requests for a user), but it does not explicitly say when not to use it or mention alternatives. The implied usage is sufficient for a simple read 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and a prerequisite, but does not disclose side effects (e.g., whether funds are moved immediately), return behavior, idempotency, or error conditions. For a money-movement tool, this is insufficient 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 two short sentences with no wasted words. The verb and object are front-loaded, making it immediately scannable and effective.

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

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

Despite having five parameters and no output schema, the description omits critical context: what happens after initiation, how to check status, potential side effects, and any prerequisites beyond KYC. The tool is under-specified for an agent to use it safely and 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?

The input schema provides descriptions for all five parameters (100% coverage), so the schema already carries the semantic load. The description adds no extra parameter-level detail beyond the schema, meriting 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 action ('Initiate') and the resource ('a fiat deposit via Brale'), distinguishing it from related tools like request_withdrawal. The KYC requirement adds a specific precondition that sharpens the 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 a key prerequisite ('Requires verified KYC'), which is a form of usage guidance. However, it does not explicitly state when to choose this tool over alternatives (e.g., transfer_tokens or request_withdrawal) or when not to use it.

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

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

With no annotations, the description must fully disclose behavioral traits. It states the action and return token but omits side effects (e.g., creation of a KYC session, possible user notification), permissions needed, or idempotency. For a tool that likely triggers an external workflow, this is a significant gap.

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

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

The description is a single sentence that conveys both the action and the return value. There is no redundant or irrelevant information, and it is easy to scan quickly.

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 low complexity (two optional params, no output schema) and full schema coverage, the description covers the core purpose. However, it lacks behavioral context such as side effects or prerequisites, which is especially important since annotations are absent. It is minimally viable but not fully 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% coverage with descriptions for both parameters (userId and ttlInSecs), so the baseline is 3. The description adds no additional parameter meaning beyond what the schema already provides, but it does not need to compensate given the full schema coverage.

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

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

The description uses a specific verb ('Initiate') and exact resource ('KYC verification for a user'), and includes the output ('Returns a Sumsub access token'). This clearly distinguishes it from sibling tools like get_kyc_status, which would report on verification state rather than start it.

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

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

The description clearly implies this is the tool to begin KYC verification for a user, as opposed to checking status (get_kyc_status). However, it does not explicitly state when not to use it or mention any alternatives, so it lacks explicit exclusion guidance.

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

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

With no annotations, the description must carry behavioral disclosure. It implies a read-only operation via 'List' but does not disclose output format, pagination, token types included, or any authentication requirements. It is not misleading, but it is minimal for an unannotated tool.

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

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

The description is a single, front-loaded sentence with no redundant wording. It earns every word and is easy to scan.

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

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

For a zero-parameter listing tool with no output schema, the description is reasonably complete: it identifies the operation and resource. However, it omits any detail about the return payload or whether 'available' means user-specific eligibility, leaving minor ambiguity for a tool with no other structured context.

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

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

There are zero parameters, so the baseline is 4. The empty schema is fully covered, and the description adds the semantic context of 'available Hedera tokens', which gives meaning beyond the empty input 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 uses a specific verb 'List' and identifies the resource as 'all available Hedera tokens for the platform', clearly distinguishing this from sibling tools like list_supported_currencies and get_balances. The scope is unambiguous.

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

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

No usage guidance is provided. The description states only what the tool does and gives no when-to-use or when-not-to-use context relative to siblings, such as whether to prefer this over get_balances or list_supported_currencies for token-related queries.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It says 'Returns active offers' which implies read-only and filtering by activity, but it does not mention authentication, pagination behavior, or the exact structure of 'trade stats'. This is minimally sufficient for a list operation.

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: two short sentences with no wasted words. It leads with the core action and then specifies the return value, 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?

While the description captures the primary purpose, it omits key context such as whether the market list includes all users' offers or just the user's own. It also does not describe the return format beyond 'trade stats', which is notable given there is no output schema. The optional filters are well-documented in the schema, so the description is partially 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 schema covers all 6 parameters with 100% description coverage, so the baseline is 3. The tool description does not add additional meaning about parameter interactions or defaults beyond what the schema already provides.

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

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

The description clearly states the action ('Browse the prediction market') and the resource ('active offers with trade stats'). It distinguishes from sibling tools like get_my_offers (which focuses on user-specific offers) and get_offer (which targets a single offer).

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 market browsing but does not explicitly contrast with alternatives such as get_my_offers or get_offer. No when-not-to-use guidance is provided, though the verb 'browse' hints at public market exploration.

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

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

No annotations are present, so the description carries the full burden. It implies a read-only operation via 'List' but discloses no additional behavioral traits (e.g., rate limits, authentication needs, output format). For a simple list tool, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence that clearly states the tool's action and scope with 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 simplicity (zero params, no output schema), the description is sufficiently complete: it states what is listed and the platform scope. It could mention the return format, but that is not necessary for a straightforward list tool.

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

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

The tool has zero parameters, so the schema is fully covered. The description adds no parameter details, but none are needed. Baseline for 0 params is 4.

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

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

The description uses a specific verb ('List') and a clear resource ('all supported currencies and tokens on BananaCrystal'). It distinguishes from the sibling 'list_available_tokens' by explicitly covering both currencies and tokens, not just tokens.

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. The sibling tool 'list_available_tokens' could overlap, but the description does not clarify how to choose between them.

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

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

With no annotations, the description must carry the disclosure burden. It discloses the platform-wide scope and filter options, but does not mention pagination, response format, rate limits, or any data sensitivity. This is adequate for a simple read-only list tool, but not rich in behavioral detail.

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: two short sentences that front-load the purpose and follow with the filtering capability. Every word earns its place 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 low-complexity tool with two optional parameters and full schema coverage, the description covers the essential purpose and scope. It does not describe the return value or pagination, but given the absence of an output schema, this is a minor gap for a simple list tool.

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

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

Schema coverage is 100%, so both parameters are already described in the input schema. The description merely paraphrases 'Filter by trade type or state' without adding any new meaning or detail beyond what the schema provides.

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

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

The description clearly states the tool lists all trades on the platform, using the verb 'List' and the resource 'trades'. It implicitly distinguishes from get_my_trades by specifying 'all trades on the platform', but it does not explicitly name alternatives or differentiate from get_trade.

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: use this to list all platform trades and filter by trade type or state. It does not explicitly state when not to use it or mention alternatives like get_my_trades, but the platform-wide scope is implied 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?

With no annotations, the description carries the burden of behavioral disclosure. It states the tool returns 'pong', which is the entire behavior. It does not explicitly mention side effects, but for a health check, this is inherently a safe read-only operation, and the description is sufficiently transparent.

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 concise sentence that front-loads the essential information. Every word earns its place, with no redundancy or filler.

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

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

For a zero-parameter tool with no output schema, the description is fully complete. It explains the tool's purpose and expected response, leaving no gaps for an agent to interpret.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter information because none is needed; the schema already covers the absence of parameters.

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

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

The description clearly states the tool is a health check that returns 'pong', which is a specific and unambiguous purpose. It distinguishes itself from siblings like echo and get_server_info by its unique health check role.

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 labels the tool as a 'health check tool', providing clear context for when to use it (to verify API connectivity). While no alternatives are named, the simplicity of the tool and absence of comparable siblings make this acceptable.

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

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

With no annotations, the description carries the transparency burden. It discloses that the target receives an approval email, but does not explain whether the transaction executes immediately, how to track the request, or what happens on approval/rejection. Some important behavioral details are missing.

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 succinct sentence that clearly states the purpose and the key consequence. No unnecessary words are present.

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 absence of an output schema and annotations, the description is somewhat sparse. It states the approval email behavior but does not indicate what the requester receives (e.g., a request ID) or how to follow up. The rich parameter schema compensates partially, making this adequate but not fully 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 provides 100% parameter coverage, so the description does not need to elaborate on each parameter. The description does not add additional parameter meaning beyond the schema, but the schema itself is descriptive (e.g., reason is 'Human-readable reason shown in approval email'). 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 specifies the action 'Request a transaction on behalf of another user' with a clear verb and resource. It also distinguishes itself from sibling tools like transfer_tokens or swap_currency by indicating an approval workflow ('They will receive an email to approve').

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

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

The description provides clear context: this is for requesting a transaction on behalf of someone else, implying it should be used when the target user must approve. However, it does not explicitly mention alternatives or when not to use it, so it falls short of a 5.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It adds the key fact that an email will be sent with the code, which is useful. However, it does not disclose other potential behaviors such as authentication requirements, rate limits, or whether prior OTPs are invalidated. It provides some transparency but not comprehensive coverage.

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

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

The description is extremely concise with two short sentences, front-loaded with the primary action. The 'Step 1' prefix is efficient and informative. No redundant information or fluff.

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

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

For a simple tool that requests an OTP and sends it via email, the description is nearly complete. It states the purpose and the delivery mechanism. It does not describe the response format or explicitly mention the next step, but given the tool's simplicity, this is acceptable. The output schema is absent, so a bit more detail on the response could help, but it is not a critical 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?

The input schema has 100% parameter description coverage, so the baseline is 3. The description does not add any parameter-specific meaning beyond what the schema already provides, but it also does not need to since the schema fully covers the parameters.

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

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

The description clearly states a specific action ('Request an OTP code') with a well-defined resource and purpose ('to authorize a token transfer'). The 'Step 1' prefix frames it as an initial action in a process, and it is distinct from sibling tools like transfer_tokens or request_withdrawal.

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?

'Step 1' provides clear context that this tool is a prerequisite for token transfers, implying when it should be used. However, it does not explicitly name alternatives or exclusions (e.g., if an OTP already exists). The context is clear enough for an agent to infer its placement.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It mentions 'Requires verified KYC' but fails to state that this initiates a real financial transaction, any side effects, irreversibility, or that it might be asynchronous. The description is sparse for a money-movement tool.

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, two short sentences, and front-loaded with the action. Every word serves a purpose; there is 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?

Given the tool has 5 parameters, no annotations, and no output schema, the description is incomplete. It does not mention what to expect in the response, that the request is likely asynchronous, or suggest using get_withdrawal_status to track progress. More context is needed for a withdrawal operation.

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

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

All five parameters have schema descriptions (100% coverage), so the baseline is 3. The description adds no additional parameter semantics beyond what the schema already provides.

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

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

The description clearly states the action ('Request'), the resource ('a fiat withdrawal'), and the platform ('via Brale'). It distinguishes itself from sibling tools like transfer_tokens and initiate_deposit by specifying 'fiat withdrawal'.

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 clear context for when to use this tool (for fiat withdrawals) and includes a prerequisite (verified KYC). However, it does not explicitly mention alternatives or exclusions, such as using transfer_tokens for crypto withdrawals.

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

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

With no annotations provided, the description carries the burden. It clearly states the reset effect and the key-type restriction, though it does not explicitly warn that current balances will be overwritten. The term 'reset' implies this, making it adequately transparent.

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 action and followed by a key constraint. Every word is purposeful with no redundancy between the two sentences.

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

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

For a zero-parameter tool with no output schema, the description fully covers the operation, its effect, and its usage precondition. Nothing critical is missing.

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

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

There are no parameters, so schema coverage is trivially 100%. The description does not need to add parameter details; baseline for zero-parameter tools is 4.

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 (reset) and resource (sandbox account balances) with a specific outcome (back to default pre-seeded amounts). It distinguishes itself from sibling tools like get_balances by indicating a mutating reset operation.

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

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

The description explicitly constrains usage to sandbox keys (bc_test_*), implying not to use with production keys. It does not name alternative tools, but the boundary is clear enough for a unique operation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions that the exchange rate is calculated automatically, but it does not disclose that this is a transactional, likely irreversible operation with potential fees, authorization requirements, or a specific response format. For a mutation tool, this is a significant gap.

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

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

The description is a single sentence that immediately states the action and the key differentiator. Every word earns its place, and there is zero filler or repetition of schema 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?

The tool performs a token swap, which is a non-trivial transaction on Hedera. With no annotations, no output schema, and only a terse description, it lacks critical operational context: return value (e.g., transaction ID), possible side effects, prerequisites (e.g., approvals, OTP), and relationship to related tools like estimate_swap_fees. This is incomplete for a transactional 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?

The schema description coverage is 100%, so the baseline is 3. The description's mention of automatic exchange rate calculation adds the insight that no separate rate parameter is needed, but it does not add detail about the individual parameters beyond what the schema already provides. The schema itself describes each parameter with examples, so the description is neither redundant nor insufficient.

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

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

The description uses the specific verb 'Swap' with a clear resource ('between two Hedera tokens') and adds the key detail that exchange rate is calculated automatically. This distinguishes it from siblings like estimate_swap_fees and get_exchange_rate, which focus on fees or rates rather than executing the 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?

The description implies the usage context—use this tool when you want to swap between two Hedera tokens. However, it does not explicitly mention alternatives or when not to use it, such as 'if you only need the exchange rate, use get_exchange_rate' or 'if you need to transfer without swapping, use transfer_tokens.'

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the OTP conditional behavior, which is a key behavioral trait. However, it does not mention potential side effects (e.g., irreversibility, balance changes) or error handling, though the verb 'transfer' implies a write operation. Overall, it provides useful context beyond the obvious.

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 'Step 2' to establish workflow context, and every sentence adds meaningful information. It avoids redundancy with the schema and is highly 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?

Given the tool's moderate complexity (6 params, no output schema), the description is fairly complete: it explains the OTP workflow step and parameter requirements. However, it does not describe return values or success/failure indicators, which could be important for the agent to verify the transfer outcome. Despite this, the high schema coverage and clear step context make it sufficiently complete for correct invocation.

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

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

The schema covers all six parameters with descriptions, so the baseline is 3. The description adds value by explaining that 'otpCode' and 'transactionRef' are only required when OTP is enabled and that they come from 'request_transfer_otp'. This contextual linkage is not present in the schema and clarifies conditional parameter usage.

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 action: 'Execute the token transfer.' It uses a specific verb and resource, and positions itself as 'Step 2' in a workflow, distinguishing it from the sibling tool 'request_transfer_otp' which handles the OTP request step. This makes the purpose unambiguous.

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

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

The description provides clear usage guidance by referencing the OTP flow: it instructs the agent to provide 'otpCode and transactionRef from request_transfer_otp' when OTP is enabled, and notes these fields can be omitted when OTP is disabled. This explicitly covers when and how to use the tool relative to its prerequisite.

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

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

No annotations are provided, so the description must carry the full disclosure burden. It only says 'update' without describing side effects, permission requirements, or whether changes take effect immediately. This is a mutation with no 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 a single, front-loaded sentence that names the tool's purpose and the key settings. Every word contributes, with no filler or repetition.

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

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

The tool is simple, but with no annotations and no output schema, the description should provide more context. It explains what is updated but not the outcome shape, error behavior, or relationship to other agent settings. The parameter schema covers the inputs, but behavioral context 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?

Schema coverage is 100%, with each parameter having its own description. The tool description adds minimal value beyond listing the parameter names, which are already in the schema. The naming mismatch (snake_case in description vs camelCase in schema) could cause minor confusion, but the schema descriptions are sufficient.

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

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

The description clearly states the verb 'update' and the resource 'agent approval settings', enumerating the specific settings (require_human_approval, require_otp, callback_url). This distinguishes it from sibling tools like get_agent_config, which reads settings.

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

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

The description implies usage for modifying agent approval settings, but it does not explicitly state when to use this tool versus alternatives like get_agent_config for viewing settings. No exclusions or prerequisites are mentioned.

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

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

With no annotations, the description bears full responsibility for behavioral disclosure. It adds one key behavioral fact—the no-trades precondition—but does not explain what happens if the precondition is violated, what authorization is needed, or whether changes are reversible. While 'Edit' implies mutation, other behavioral aspects remain undisclosed.

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

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

The description is two sentences with no wasted words. It front-loads the purpose and follows with a critical usage constraint. Every word earns its place.

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

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

The description is minimal but sufficient for a basic edit tool given the rich schema. However, it omits details about response behavior, error handling on condition failure, and any side effects (e.g., whether it re-activates an offer). For a mutation tool with no annotations and no output schema, more context would be 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 description coverage is 100%, so the schema already documents each parameter thoroughly. The description adds no additional parameter-level detail, meeting the baseline for covered schemas.

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: 'Edit an existing offer.' This is a specific verb-resource pairing that distinguishes it from sibling tools like create_offer, delete_offer, and delist_offer. The additional constraint about no trades further clarifies its scope.

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

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

The description provides a clear precondition: 'Only allowed when the offer has no trades yet.' This tells the agent when this tool is appropriate and implicitly when it is not (if trades exist). However, it does not explicitly mention alternative tools or when to prefer them, so it falls short of full guidance.

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