Lobex

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

Beyond the readOnlyHint=false annotation, it discloses the meaningful behavioral effect: releasing escrow to the seller. The alias note adds useful context. It does not mention irreversibility or permissions, but the core side effect is clear.

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, immediately front-loaded with '[Buy]' and the alias note. It communicates the essential purpose without waste.

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

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

For a simple tool with one parameter and no output schema, the description covers the core action. However, it does not explain the outcomes or return values, and the alias relationship could be clearer about whether ack_purchase is deprecated in favor of confirm_delivery.

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 one parameter, purchaseId, with no description coverage. The description does not explain what purchaseId represents or how to format it. The parameter name is self-explanatory to some degree, but the description adds no semantic value for it.

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

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

The description clearly states the action: 'buyer releases escrow to seller' and identifies it as an alias of confirm_delivery. This is a specific verb+resource combination that distinguishes it from sibling tools, though its relation to confirm_delivery is explicit.

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

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

It names confirm_delivery as the alternative sibling and gives the context of releasing escrow, which implies when to use. It does not explicitly state when not to use it or why an agent might prefer confirm_delivery, but the context is clear enough.

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

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

Annotations already indicate readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds behavioral context that the tool returns actionable next tool steps, which is useful but doesn't disclose side effects or authentication needs. No contradiction with annotations.

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

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

Single 13-word sentence, front-loaded with purpose, condition, and output. Every word earns its place and 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?

While the tool's purpose and return type are clear, the lack of parameter explanations and absence of an output schema make it incomplete for an agent to invoke with correct arguments. It also doesn't cover usage variations beyond the buy/sell scenario.

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

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

Schema description coverage is 0%, and the description only implies the 'question' parameter. It doesn't explain 'context', 'provider', or 'stuckState', leaving the agent without guidance on how to populate these fields.

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 specific verb 'Ask' with resource 'Lobex help', scopes it to 'when stuck on buy or sell', and states the outcome 'Returns actionable next tool steps.' This clearly distinguishes it from sibling action tools like buy_credits or purchase_service.

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

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

It explicitly says 'when stuck on buy or sell', providing a clear trigger condition for use. It doesn't name alternatives or exclusions, but the context of sibling tools implies it's for troubleshooting rather than direct actions.

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

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

Annotations already indicate the tool is not read-only and not destructive. The description adds the behavioral context that this is a legacy alias to buy_gas, which is useful but does not disclose specific side effects such as crediting the account or deducting balance. Given the annotations cover the safety profile, 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 sentence that immediately states the tool's role as an alias and its legacy status, followed by a clear preference instruction. Every word is informative and the structure is optimally front-loaded.

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

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

The tool is a simple alias with one parameter and no output schema. The description adequately redirects to buy_gas and explains the legacy nature, which is sufficient for an agent to understand the tool's role. It could benefit from specifying the underlying purchase behavior, but the sibling pointer mitigates that.

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

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

The description provides no information about the packId parameter, and schema description coverage is 0%. Although the schema's enum values (starter, builder, fleet) are self-explanatory, the description fails to compensate for the lack of parameter documentation.

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 tool as a legacy alias for buy_gas, which distinguishes it from the sibling tool buy_gas. However, it does not explicitly describe the underlying operation (e.g., 'purchases credits'), relying on the tool name and buy_gas's own description for full meaning.

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 instruction 'Prefer buy_gas' provides explicit guidance that this tool should be avoided in favor of buy_gas, making the usage context very clear. It does not specify when to use this legacy alias, but the preference alone is sufficient.

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

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

Annotations indicate readOnlyHint=false and openWorldHint=true, but the description adds important behavioral details: it returns a checkoutUrl, requires opening in an IDE popup/browser, and depends on 'human only approves Stripe/3DS.' This goes beyond the binary annotations and explains the interactive payment flow.

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 tightly packed with essential information in three sentences: action, return value, human step, pack details, and gas-to-dollar peg. Every sentence adds value, and it is front-loaded with the primary purpose.

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

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

For a simple purchase tool with no output schema, the description covers the return value, pack options, pricing, and the human approval step. It lacks failure scenarios or post-payment steps, but these are not critical for a basic checkout flow.

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 covers packId with enum descriptions, but the description enriches understanding by adding concrete quantities and prices: 'starter (500/$5), builder (2000/$20), fleet (10000/$100).' This adds meaning beyond the schema's simple labels.

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: 'Buy gas via Stripe Checkout (fund wallet for Buy or Sell).' It specifies the resource (gas) and the mechanism (Stripe Checkout), distinguishing it from sibling tools like buy_credits or purchase_service by focusing on wallet funding.

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

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

The description explains the tool is for 'fund wallet for Buy or Sell' and lists pack options, giving clear context for when to use it. However, it does not explicitly mention when not to use it or name alternative tools, though the 'Shared' prefix and sibling list provide some context.

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

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

Annotations indicate a write operation with an open-world effect, but the description adds no behavioral context such as transaction fees, delays, or side effects. It does not contradict annotations, but it also contributes nothing beyond what annotations already reveal.

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 text is extremely short, but this is under-specification rather than effective conciseness. It omits essential information about the tool's purpose and parameters, leaving the agent without necessary guidance.

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

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

This is a three-parameter mutation tool with no output schema and no parameter documentation. The alias reference provides no operational clarity, and the tool is far from complete for an agent to invoke correctly.

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

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

Schema description coverage is 0%, yet the description does not explain any of the three parameters. gasAmount, btcAddress, and paymentDetails have only basic type and constraint information in the schema, and the tool description offers no clarification about their purpose or format.

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 only says it is an alias for request_cashout, without stating what cashing out actually does. The '[Sell]' prefix offers a vague hint, but there is no explicit verb or resource. It does not meaningfully distinguish this tool from its siblings beyond referencing another tool.

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 request_cashout or other selling tools. There is no mention of context, prerequisites, or situations where this alias should be 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?

Annotations already flag this as destructive and write-oriented. The description adds valuable behavioral context beyond annotations: the financial outcome (90% to seller, 10% platform fee) and that the buyer initiates escrow release. This helps the agent understand the irreversible financial 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 concise sentence, front-loaded with the '[Buy]' category. Every word adds value, including the percentage split, and there is no wasted text.

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

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

For a simple one-parameter tool with clear annotations, the description covers the essential outcome and actor. It lacks explicit failure handling or prerequisites, but the simplicity and annotations make it adequate. It is more complete than a bare mutation 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?

Schema coverage is 0% and the description does not mention the purchaseId parameter. The parameter name is self-explanatory, but the description provides no additional meaning or format guidance, leaving the agent with minimal information about this required input.

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: the buyer releases escrow, with proceeds split 90/10 between seller and platform. This is a specific action tied to the tool name, and it distinguishes itself from siblings like dispute_purchase or ack_purchase.

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: the buyer confirms delivery to release escrow. However, it does not explicitly contrast with alternatives or state when not to use it. The context is clear but not formalized with exclusions or alternative guidance.

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

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

The description adds the context of being legacy and optional, but does not disclose the actual behavior of the onboarding process (e.g., external redirects, required Stripe account setup). Annotations indicate it is not read-only and not destructive, but the description adds limited additional 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, concise sentence that front-loads the category '[Sell]' and clearly states the tool's status and alternative. Every word earns its place with no wasted space.

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

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

Given zero parameters, no output schema, and the clear pointer to 'request_cashout', the description is adequate for an optional legacy tool. Some detail about what 'onboarding' entails is missing, but the low complexity and sibling context make it reasonably 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?

There are zero parameters, so the schema is trivially complete. The description doesn't need to explain parameters, and the baseline for a no-parameter tool 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 identifies the tool as 'Legacy Stripe Connect onboarding' and positions it as optional for sellers, which clearly differentiates it from the primary 'request_cashout' sibling. It lacks a strong action verb but still conveys the specific resource and 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?

Explicitly states that the primary cashout path is 'request_cashout' and marks this as 'optional' and 'legacy', giving clear guidance to prefer the alternative. This is strong 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?

The description adds behavioral context beyond the annotations by specifying that it 'Marks status delivered' and is tied to an escrow purchase. Since annotations already indicate a non-read-only, non-destructive operation, the description supplements them without contradiction.

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

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

The description is two sentences, front-loaded with '[Sell]', and every word serves a purpose. It is concise and well-structured without 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?

The description covers the core action and effect, including the escrow context, and the schema and annotations provide additional structure. However, it lacks details on parameter interaction (e.g., whether 'url' or 'body' is required) and post-delivery behavior, which keeps it from being 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?

With schema description coverage at 50%, the description clarifies that the tool is for submitting a digital deliverable, which maps to 'url' and 'body', but it does not explain 'purchaseId' or 'contentType'. This leaves some parameter meaning unexplained beyond the schema.

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

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

The description clearly states a specific verb ('submits') and resource ('digital deliverable for a purchase in escrow'), and it distinguishes itself from sibling tools like confirm_delivery by specifying the seller's action. It also notes the effect ('Marks status delivered'), making 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 '[Sell]' prefix provides some context for when to use the tool, but there is no explicit mention of alternatives or exclusions. It does not reference related tools like confirm_delivery or get_delivery, leaving the usage boundaries implied rather than explicit.

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

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

The description adds meaningful behavioral context beyond the annotations, specifically that escrow is frozen and seller cashout is blocked. Annotations only indicate non-read-only and non-destructive, but the description details the real-world consequences. It does not disclose reversibility or prerequisites, but the disclosed effects are 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 extremely concise, consisting of two short sentences. It front-loads the action and immediately states the critical outcomes, with no redundant or filler content.

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

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

The description covers the essential behavior of the tool, including the core effect of freezing escrow and blocking seller cashout. It does not explain the full dispute lifecycle or return values, but for a simple mutation with two self-explanatory parameters, the provided context is largely sufficient.

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

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

Schema description coverage is 0%, and the description provides no information about the parameters (purchaseId and reason) or their expected values. It does not compensate for the lack of schema detail, leaving the agent without additional semantic guidance.

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

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

The description clearly states the action: 'Buyer opens a dispute' and specifies the key effect 'Freezes escrow (no auto-release) and blocks seller cashout.' This directly conveys the tool's purpose and distinguishes it from siblings like request_refund or ack_purchase.

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 tool is for buyers to open a dispute, but it does not explicitly state when to use it over alternatives (e.g., request_refund, confirm_delivery). No exclusions or alternative references are provided, so usage guidance is mostly implied.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'retrieves' aligns with that. The description adds the detail that both buyers and sellers can retrieve, but does not disclose error behavior, permissions, or return format beyond the basic 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 a single, focused sentence with no redundant words. It front-loads the category '[Buy]' and immediately states the 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 read-only tool with one parameter and existing annotations, the description conveys the essential purpose. However, without an output schema, it would benefit from clarifying what 'deliverable' means (e.g., file content, link) and any prerequisites, though these are partially covered by the '[Buy]' category.

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 a single purchaseId parameter with no description coverage. The description's 'for a purchase' implies purchaseId identifies the purchase, and the parameter name is self-explanatory, but the description does not explicitly define the parameter's format or usage beyond that inference.

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 ('retrieves'), the resource ('deliverable'), and the scope ('for a purchase'). It also specifies the actors (buyer or seller), which helps distinguish it from sibling tools like get_purchase or deliver_work.

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 this tool is used to retrieve a purchased deliverable, but it does not explicitly state when to use it over alternatives such as get_purchase or confirm_delivery. No exclusions or alternative guidance is provided.

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

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

Annotations already declare readOnlyHint and destructiveHint false. The description adds context about user scoping ('you are party to') and delivery inclusion, but doesn't disclose behavior like error cases or return formatting.

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, no fluff, includes a category prefix and key scoping 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 simple get-by-ID tool with annotations, the description covers the essential scope and delivery inclusion. However, it lacks any mention of response format or error handling, and given openWorldHint, more context could be helpful.

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

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

The single parameter purchaseId is self-explanatory from its name, but the description doesn't explicitly connect it to the schema or add meaning beyond the obvious. Schema description coverage is 0%, so the description carries some burden, but the parameter name compensates.

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 retrieves a single purchase/order the user is party to, distinguishing it from list_orders by specifying 'one' and from get_delivery by including delivery details when submitted.

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 a specific purchase by ID but doesn't explicitly name alternatives like list_orders or get_delivery, nor does it state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds that messages include both buyer and seller, but does not disclose ordering, pagination, or return format. Thus it provides minimal behavioral context beyond what annotations offer.

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 conveys the core purpose with no wasted words. It is 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?

For a simple read-only listing tool, the description covers the key scope (purchase/order thread) and participants (buyer and seller). It omits details like default limit and message ordering, but the schema provides the limit bounds and the annotations confirm safety. Given the simplicity, it is reasonably 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 0%, and the description does not elaborate on purchaseId or limit. It only implies that messages are tied to a purchase thread, leaving the limit parameter completely unexplained. The description fails to compensate for the lack of schema descriptions.

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

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

The description clearly states the verb 'List' and the resource 'messages on a purchase/order thread', which distinguishes it from siblings like send_message and list_orders. The scope is specific and unambiguous.

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

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

The description implies the use case (viewing messages on a purchase thread) but does not explicitly state when to avoid using this tool or recommend alternatives. Guidance is present only through context, not explicit exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that it lists purchases with escrow statuses, but it does not disclose output structure, pagination behavior, or how orders are ordered.

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 brief and front-loaded with a [Buy] tag, making it easy to scan. The typo 'escup' and the lack of parameter details reduce its effectiveness, but it is still concise overall.

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 no output schema and two parameters, the description is too terse. It does not explain what information is returned per order, how limit affects results, or how openWorldHint (potentially incomplete world view) impacts the data. This leaves significant gaps for a listing 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 0%, so the description must explain parameters. It only partially clarifies role by mentioning 'role=buyer' but does not explain the 'seller' or 'all' options, and limit is entirely unexplored. The schema provides enums but no descriptions, leaving the agent without guidance.

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

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

The description uses the specific verb 'List' with the resource 'purchases' and indicates role-based filtering ('buyer and/or seller'), which helps distinguish it from single-order tools like get_purchase. However, the typo 'escup statuses' instead of 'escrow statuses' slightly muddies the meaning.

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

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

It provides a concrete usage hint ('Use role=buyer for buy workflow') but does not mention when to use buyer vs seller or all, nor does it contrast with alternative tools such as get_purchase for retrieving a single order.

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

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

Annotations already indicate a non-read-only, non-destructive, open-world operation. The description adds valuable context: the platform fee of 10% and the requirement that description must state buyer inputs and outputs. These are behavioral details not covered by annotations. No contradiction exists.

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

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

The description is concise: four short sentences, each providing distinct information (purpose, description constraint, category preference, fee). It is front-loaded with the primary action and avoids redundancy or fluff.

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

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

For a create operation with no output schema, the description covers the essential aspects: what the tool does, the fee, and key parameter guidance. It does not mention details like listing visibility or lifecycle, but the open-world annotation and simple nature of the tool reduce the burden. Overall, it is sufficiently complete for an agent to select and 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 50%, covering priceGas and description. The description adds meaningful constraints beyond the schema: 'Description must state buyer Inputs and Outputs' and category preference for codegen/research/ops. This helps clarify the purpose and usage of the description and category 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's function: 'Create a marketplace listing priced in gas.' The '[Sell]' prefix further clarifies that this is for selling, distinguishing it from siblings like purchase_service and update_service. The action and resource are specific and unambiguous.

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

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

The '[Sell]' prefix and 'Create a marketplace listing' provide clear context that this tool is for selling services, as opposed to buying or updating. It also offers category guidance ('Prefer wedges codegen|research|ops'), which helps with parameter selection. However, it does not explicitly mention alternatives or when not to use this tool.

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

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

Annotations indicate readOnly=false and destructive=true. The description adds the key behavioral detail that gas is debited into escrow and seller remains unpaid until confirm_delivery, which is not in annotations. This discloses the financial flow and escrow state, going beyond schema and annotations.

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

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

The description is one succinct sentence that front-loads the action and follows with the key escrow detail. No unnecessary words.

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

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

For a single-parameter transaction, the description covers the core behavior and lifecycle (escrow, awaiting_delivery, seller payment timing). However, it does not mention prerequisites like sufficient balance or return values, which would be useful given no output schema.

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

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

The input schema has one parameter, listingId, with 0% description coverage. The description says 'Buy a listing,' which implicitly ties listingId to the listing being purchased, but it does not explicitly define the parameter's meaning or constraints (e.g., must be a valid listing ID). This provides minimal but sufficient context given the single 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?

Description clearly states 'Buy a listing' with a specific verb and resource. It distinguishes from sibling tools like buy_gas/buy_credits by targeting listing purchases. The phrase 'debits buyer gas into escrow' further specifies the purchase mechanism.

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

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

Provides clear context: the tool initiates a purchase and places funds in escrow until confirm_delivery, implying when to use it (for buying listings). However, it does not explicitly mention alternatives or exclusion conditions, 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description adds value by disclosing the side effect on seller ratingAvg and the conditional delivery confirmation. This goes beyond what the schema or annotations provide.

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

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

The description is three short sentences that each convey a distinct piece of information: the action, the conditional behavior, and the side effect. There is no wasted wording.

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 three parameters and no output schema, the description covers the core behavior, the conditional action, and the outcome. The missing 'note' parameter is a minor gap, but overall the description is sufficiently complete for 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?

With 0% schema description coverage, the description must compensate. It mentions the rating scale (1-5) and implies purchaseId as the target, but it does not explain the 'note' parameter at all. The rating scale is already in the schema as min/max, so the description adds minimal new information.

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: the buyer rates a purchase on a 1-5 scale and updates the seller's rating average. It uses a specific verb ('rates') and resource ('purchase'), and the conditional delivery confirmation distinguishes it from sibling tools like confirm_delivery.

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 indicates when the tool is applicable by specifying the buyer role and the conditional behavior when escrow is still held. It does not explicitly name alternatives or say when not to use it, but the context is clear enough for an agent to decide.

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

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

Annotations already indicate a write operation (readOnlyHint=false). The description adds important behavioral details: the API key is one-time and shown only once, requiring immediate storage. It also notes the 'call once per install' constraint, which goes beyond the structured annotations. It could mention what happens on repeated calls, but the key constraint is disclosed.

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

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

The description is a single, 20-word sentence that front-loads the core action. Every word adds value: 'Create a new Lobex agent identity', 'one-time API key', 'call once per install', and 'store apiKey; shown once' all convey essential information without redundancy.

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

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

For a simple registration tool, the description is mostly complete: it explains the return value (one-time API key) and usage frequency. However, it omits details like what happens if called more than once and does not explain the label parameter. Given no output schema, the return value disclosure is helpful, but minor gaps remain.

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

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

Schema description coverage is only 25% (only referredBy is described in the schema). The tool description adds no parameter information, leaving label, provider, and displayName unexplained. Because the description does not compensate for the low schema coverage, parameter semantics are 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 clearly states 'Create a new Lobex agent identity and return a one-time API key.' This gives a specific verb ('create') and resource ('Lobex agent identity'), making the tool's purpose unambiguous. It also distinguishes it from sibling tools by being the only identity-creation tool.

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

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

The description provides clear usage context: 'Call once per install' and 'Store apiKey; shown once.' This tells when to use it and what to do with the result. However, it does not explicitly mention alternatives or when not to use it, so it stops short of full 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description does not need to restate those. It adds context about attaching context.requestId, which is helpful. However, it does not disclose what happens after a bug is filed (e.g., creates a ticket, notifies operators), and there is no output schema. The description adds some value but is not rich in behavioral details.

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

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

The description is a single sentence that is front-loaded with the core purpose ('File a bug report') and immediately provides a key usage detail. Every word is purposeful; there is no fluff or repetition. It is as concise as possible while still being informative.

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

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

With 9 parameters, no schema descriptions, no output schema, and a very brief description, the tool is under-documented. The description gives the purpose and one parameter hint, but fails to explain the required title and description fields, the severity enum, or any expected behavior. It is insufficient for an agent to reliably fill out the form correctly. The absence of usage alternatives also hurts completeness.

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

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

Schema description coverage is 0%, so the description must compensate for 9 undocumented parameters. It only mentions context.requestId, which helps with the context object, but says nothing about title, description, severity, steps, actual, expected, provider, or reproduction. This is a major gap, and the description does not meaningfully clarify parameter semantics beyond that one instruction.

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

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

The description clearly states a specific verb and resource: 'File a bug report for Lobex operators.' It also includes a concrete instruction (attach context.requestId), which distinguishes it from sibling tools like report_experience or ask_help. Purpose is unambiguous and not tautological.

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

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

The description provides clear context for when to use the tool (when filing a bug report, especially with failed API responses). It does not explicitly name alternatives or exclusions, but the purpose is specific enough that usage is well implied. Lacks explicit 'use this instead of X' guidance, so not a 5.

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

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

The description adds that the report involves a rating and journey step, but no behavioral details such as persistence or data handling. Annotations already indicate it's not read-only and not destructive, so no contradiction exists.

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

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

One sentence, front-loaded with the action and core inputs. 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 simple feedback tool, the description is adequate: it covers the key purpose and required inputs. It does not explain optional params or side effects, but these are either self-explanatory or covered by annotations.

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 description explicitly mentions the two required parameters (rating and journeyStep), but the optional parameters (context, provider, whatFailed, whatWorked) are not explained. With 0% schema description coverage, the description partially compensates but leaves gaps.

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: report success or friction with a rating and journey step. It distinguishes from sibling tools like report_bug (bugs) and rate_purchase (specifically rating a purchase).

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 use when a user wants to provide feedback about their Lobex experience, covering both positive and negative aspects. It doesn't explicitly mention alternatives, but the scope is clear and no exclusions are needed.

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

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

Annotations already mark it as non-read-only and destructive, but the description adds 'Escrows gas; operator pays BTC manually,' revealing the escrow mechanism and human-operated settlement process. This is meaningful behavioral context beyond the annotations.

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

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

Two sentences with no redundancy. The description efficiently communicates the action, scope, and a key behavioral trait (escrow and manual payment) in a compact structure.

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

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

With 3 parameters, no output schema, and a non-trivial mutation operation, the description is too sparse. It doesn't clarify the return value, the need for btcAddress despite it being optional in the schema, or the side effects of escrowing gas.

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

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

With 0% schema coverage, the description must explain parameters but only hints at gasAmount via 'earned gas.' It fails to describe btcAddress and paymentDetails, leaving their purpose and requirement ambiguous. The Bitcoin context partially compensates, but not enough.

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 'Request' and a clear resource 'Bitcoin cashout of earned gas,' making the core purpose unambiguous. It partially distinguishes from the sibling 'cash_out' by scoping to earned gas, though it doesn't explicitly name that sibling as an alternative.

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 like 'cash_out.' The context implies you should use it when you have earned gas, but it doesn't state when not to use it, prerequisites, or compare with other tools.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds meaningful context beyond that by explaining the specific effects: 'returns escrowed gas, cancels order' and clarifies the timing restriction. No contradiction with annotations.

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

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

Two concise sentences, front-loaded with the core purpose, and no wasted words. The structure efficiently communicates the key information.

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

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

The description covers the high-level purpose and usage timing well, but omits any parameter details, which is a notable gap for a 2-param tool. However, the tool is simple and annotations provide safety context, so it's minimally viable.

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

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

Schema description coverage is 0%, so the description carries full responsibility for explaining parameters. It does not mention purchaseId or reason, offering no guidance on required vs optional inputs or their meaning. This fails to compensate for the schema gap.

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 (buyer refund before confirm), the resource (escrowed gas, order cancellation), and distinguishes it from the sibling tool dispute_purchase by specifying the timing ('before confirm' vs 'after confirm').

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

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

Explicitly states when to use the tool ('before confirm') and provides a direct alternative ('After confirm, use dispute_purchase'). This fully guides the agent on tool selection.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds behavioral details about the search ('active listings') and a ranking preference ('Prefer sellers with sales or isSeed=true'), which are useful and go beyond annotations. There is no contradiction.

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

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

The description is two sentences, front-loaded with the core purpose, and contains zero wasted words. The second sentence adds actionable guidance without bloating.

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 search tool with no output schema, no parameter descriptions, and limited behavioral details, the description leaves out essential information such as result format, sorting/pagination behavior, and parameter semantics. It provides a high-level purpose but is not complete enough for an agent to invoke the tool effectively without guessing.

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 3 parameters (q, limit, category) with zero description coverage, and the description provides no explanation of what these parameters mean or how to use them. Since the description must compensate for the lack of schema documentation, and it does not, this is a significant gap.

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 'Search active marketplace listings' with a specific verb and resource, and distinguishes itself from the sibling 'purchase_service' by explicitly positioning this as a pre-purchase step. The '[Buy]' prefix further clarifies its context within the marketplace workflow.

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

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

It provides clear usage context by saying 'before purchase_service', indicating when this tool should be used. It also offers selection guidance ('Prefer sellers with sales or isSeed=true'), but does not explicitly mention when not to use it or alternative search tools, so it falls just 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?

Annotations already disclose readOnlyHint=false and destructiveHint=false, so the description adds marginal behavioral context by specifying the recipient ('other party') and thread scope. However, it omits any information about side effects, permissions, or return behavior beyond what annotations provide.

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

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

The description is a single, compact sentence with no redundant words. The [Buy] tag adds context without 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?

The tool is simple, but the description lacks parameter explanations and usage guidance, which are especially needed given the sparse schema. It provides the core purpose but not enough for an agent to confidently invoke the tool without additional inference.

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

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

With 0% schema description coverage, the description must explain parameters but fails to do so. The names 'purchaseId' and 'body' are self-explanatory to some degree, but the description does not elaborate on their semantics, formats, or constraints (such as the 4000-character limit).

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 'Send' with the resource 'message' on a purchase/order thread, clearly distinguishing it from sibling tools like list_messages. It fully clarifies the tool's function.

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 '[Buy]' prefix indicates the operational context but does not explicitly contrast with alternatives or state when not to use. The thread context implies usage for purchase communication, but no exclusions or alternative tool references 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?

The description adds the ownership constraint ('your listings') and the deactivate action, which goes slightly beyond the annotations' read/write hints. It does not explain effects like whether deactivation is reversible or what happens to the listing, so it's 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, compact sentence with no wasted words, but it is under-specified for a tool with six parameters. It earns its place but sacrifices completeness.

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 (six parameters, no output schema), the description is too sparse to guide an agent on field semantics, allowed values, or the effect of the active flag. It provides only the top-level action, leaving significant 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 0% because the description does not mention any of the six parameters. It leaves the user to infer meanings for fields like priceGas, category, and active from their names and schema constraints.

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

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

The description clearly states a specific verb+resource: update or deactivate a listing. The '[Sell]' prefix and 'your listings' distinguish it from purchase and other listing tools, making it identifiable among siblings.

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

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

The description provides context that this tool is for sellers to manage their own listings, but does not mention alternatives or when not to use it. It offers no explicit exclusions or comparisons to sibling tools like list_service.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, and the description aligns with these by using 'Get'. The description adds specific resource details (gas balance, ledger entries categorized as earnings/fees/cashouts) but lacks depth on recency window, pagination, or handling of pending entries. With annotations covering safety, 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 sentence, immediately front-loaded with the '[Sell]' context and a clear verb and object structure. No redundant words or filler; every word adds 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 simple tool with no parameters and no output schema, the description covers the core purpose well. It could theoretically mention the seller-specific context explicitly or describe the return format, but given the simple read-only nature and supportive annotations, it is reasonably 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 zero parameters, so there is nothing to explain. The baseline for no parameters is 4, and the description does not need to add parameter information.

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 ('Get') and its resource ('gas balance and recent ledger entries' with examples of entry types). This distinguishes it from sibling tools like buy_gas or cash_out, which involve transactions rather than read-only queries.

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 by the '[Sell]' prefix and the read-only nature, but the description does not explicitly state when to use this tool over alternatives like buy_gas, cash_out, or connect_payouts. No exclusions or alternative recommendations are provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context by specifying the returned data (identity and wallet balance) and framing it as a seller identity check, which goes beyond the structured fields.

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

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

A single, front-loaded sentence with the [Sell] context and no wasted words. It earns its place entirely.

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

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

For a zero-parameter, read-only identity/balance tool with no output schema, the description fully covers purpose and output. It states the two key return items and provides context for when it's used.

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

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

With zero parameters and 100% schema coverage by default, the description has nothing to add. The baseline 4 applies since the schema is trivially complete.

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 ('Return') and identifies the resources (authenticated agent identity and wallet balance). The parenthetical 'seller identity check' clarifies the tool's role in the marketplace context, distinguishing it from a generic wallet lookup.

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 'seller identity check' hint implies when to use it, but there is no explicit comparison to sibling tools like 'wallet' or conditions for when not to use it. The guidance is implied rather than stated.

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