eqvps

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

No annotations are provided, so the description carries full burden. It discloses that accepting the delegation creates/links an account and grants operator access, and returns a bearer token. This is adequate behavioral disclosure for a one-time accept 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?

Two sentences, no wasted words. The description is front-loaded with the core action and immediately specifies the required input.

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 one parameter, no output schema, and no nested objects, the description covers all necessary aspects: what happens (accepts delegation, creates/links account, grants access) and what the agent gets (bearer token). No gaps.

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

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

Schema has 0% description coverage, so the description must compensate. It explains that the 'token' parameter comes from the invite link, adding meaningful context beyond the schema's minLength constraint.

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 (accept delegation invitation), what it requires (token from invite link), what it does (creates/links account, grants operator access), and what it returns (bearer token). It distinguishes itself from siblings like 'delegate_service' and 'revoke_delegation'.

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

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

The description explicitly says to use when you have an invite link token, which implies the context of use. It does not explicitly mention when not to use or alternative tools, but the purpose 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?

Because no annotations are provided, the description carries full burden for transparency. It fully discloses the default safe behavior, the irreversible data destruction for immediate, the required confirm field, and the refund. No contradictions.

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

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

Description is well-structured and front-loaded with the purpose. It is detailed but not verbose; each sentence adds value. Slightly long but appropriate for the complexity.

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

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

Given the tool's complexity (two modes with varying effects, special confirm requirement, refund), the description is fully complete. It covers behavior, constraints, prerequisites (confirm value), and even hints at return value (refund_amount). No output schema but description compensates.

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

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

Schema has 0% description coverage, so the description compensates. It explains the type enum options ('end_of_period'/'immediate'), the confirm parameter should be the exact server hostname (referencing get_vps_status), and service_id is implied to identify the VPS. Could explicitly note service_id source.

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

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

Clearly states 'Cancel a VPS' with two distinct modes (end_of_period and immediate), specifying their effects. Differentiates from sibling tools like power_vps or reinstall_vps by explicitly describing cancellation behavior.

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

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

Provides explicit guidance: 'Use end_of_period unless you explicitly intend to wipe the server now.' For immediate, warns about destruction and requires confirm set to exact hostname. Also mentions refund for immediate.

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 notes that closing can be done without rating, but it does not disclose any side effects (e.g., whether closing is irreversible, whether it notifies the other party, or whether the ticket becomes read-only). 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?

Two sentences with no filler. The first sentence states the primary purpose, the second covers optional parameters and where to get the required input. Every sentence earns its place.

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

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

The description covers the basic purpose, optionality, and input source. However, with no annotations or output schema, it leaves out behavioral consequences (e.g., whether closing is permanent, if it affects ticket status, or any prerequisites beyond ownership). It is adequate for a simple action 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 has 0% description coverage. The description adds meaning by clarifying that rating and comment are optional, and that ticket_code should come from create_ticket/list_tickets. It also mentions the 1-5 range for rating, which mirrors the schema but reinforces it. However, it doesn't elaborate on the comment parameter or provide examples.

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 ('Close') and resource ('one of your tickets'), clearly differentiating this from sibling tools like reply_ticket or get_ticket. The scope ('one of your tickets') adds ownership context.

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

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

It explains that rating and comment are optional, and tells the agent to use the ticket code from create_ticket or list_tickets. This provides context for when to use the tool, though it doesn't explicitly exclude alternatives.

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

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

With no annotations, the description takes on the disclosure burden. It mentions required parameters and the response contains a ticket `code`, which informs the user of the outcome. However, it does not mention potential side effects (e.g., notification emails) or authentication requirements, which keeps it from a perfect score.

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 exactly two sentences. The first sentence states the purpose, and the second efficiently covers parameter requirements, optional behavior, and the response's next steps. Every word earns its place, with no unnecessary 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 absence of an output schema, the description correctly highlights the return value (ticket code) and how to use it with related tools. It lacks detail on error handling, prerequisites like authentication, or potential side effects, but for a simple create operation, 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 schema coverage is 0%, so the description must compensate. It explains that `service_id` links the ticket to a VPS and clarifies that `subject` and `message` are required. While it doesn't elaborate on the content of `subject` or `message`, their meaning is intuitive, and the description adds meaningful context for the key 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 'Open' with the resource 'support ticket', clearly stating the tool's function. It also distinguishes itself from sibling tools like get_ticket, reply_ticket, and close_ticket by explaining the ticket code 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 states that `subject` and `message` are required, `service_id` is optional, and directs the user to use the returned code with get_ticket/reply_ticket/close_ticket. This gives clear context for when to use the tool, though it does not explicitly mention alternatives or when-not-to-use scenarios.

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, description discloses key behaviors: sends invitation link, permissions granted, optional time limit. Could mention revocation possibility but sibling suggests it.

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 high information density. Front-loaded action, then details and a note on owner-only. Every sentence earns its place.

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

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

No output schema and description does not explain return value, errors, or prerequisites like login. Adequate for basic usage but lacks completeness for a tool with no 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?

0% schema coverage is compensated by description explaining email, service_id, and expires_days meaning. Adds context that expires_days is optional and for time-limited access.

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 action: granting OPERATOR access to a VPS via email. Lists exact permissions and restrictions, distinguishing from siblings like accept_delegation and revoke_delegation.

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

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

Explicitly says 'Owner-only' and that it sends an invitation, guiding when to use. Lacks explicit comparison to accept_delegation or revoke_delegation, but context 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?

No annotations are provided, so the description carries the full burden. It states the return value but does not explicitly confirm that the operation is read-only or disclose any potential side effects, authentication requirements, or rate limits. The behavioral disclosure 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 consists of two concise, front-loaded sentences. Each sentence adds value: the first describes the core function, the second provides relevant context about its use with another tool. No unnecessary words.

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

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

Given the simplicity of the tool (no parameters, no output schema), the description is completely adequate. It specifies what is returned (balance and currency) and how it relates to order_vps, which is sufficient for an agent to understand its role.

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 no parameters, so schema coverage is 100%. With zero parameters, the baseline is 4. The description adds no parameter information, but none is needed.

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

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

The description clearly specifies that the tool returns the account's prepaid credit balance and currency. It also distinguishes itself from sibling tools like order_vps (spends balance) and topup_balance (adds balance) by mentioning the spending relationship.

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

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

The description implies when to use the tool (to check balance before ordering) but does not explicitly state when not to use it or provide alternative tools. The context about order_vps spending from this balance gives practical 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 carries the full burden of behavioral disclosure. It reveals that the tool returns the full message thread, that each message has an author field with values 'you' or 'staff', and that 'staff' messages are replies from support. This goes beyond a bare 'read' operation and gives useful behavioral context, though it omits details like error handling or rate limits.

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 with no filler. The opening sentence immediately states the purpose, followed by useful message-thread details and a sourcing hint. Every sentence earns its place.

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

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

For a simple one-parameter read tool with no output schema, the description covers the essential use case, message structure, and polling behavior. It could be slightly more explicit about the return shape, but it is complete enough 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%, so the description compensates by explaining what the single parameter 'ticket_code' is used for and where to obtain it ('comes from create_ticket / list_tickets'). This adds meaning beyond the schema's bare type/minLength definition, though it does not specify the exact format or length 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 uses a specific verb ('Read') and resource ('one ticket and its full message thread'), clearly distinguishing it from sibling tools like list_tickets, create_ticket, reply_ticket, and close_ticket. It immediately conveys the tool's core function without 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?

It states when to use the tool ('Poll this to see new answers') and where the input comes from ('The ticket code comes from create_ticket / list_tickets'). It does not explicitly mention when not to use it, but the context is clear enough for an AI agent to select it appropriately.

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 burden. It mentions 'time-series' but does not clarify whether data is live or historical, aggregation granularity, or data retention. Mutation safety is not 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 extremely concise with a single clear sentence and a parameter note. Every word adds value, no fluff.

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

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

Despite low complexity (2 params), no annotations or output schema exist. The description omits return format, whether data points are discrete or aggregated, and any constraints like rate limits. Incomplete for an agent to fully understand the tool's behavior.

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

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

Schema description coverage is 0%. The description adds meaning for the 'timeframe' parameter (enum values, default) but does not describe the required 'service_id' parameter. This partial compensation yields a baseline score.

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

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

The description clearly states the verb 'get', the resource 'VPS metrics', and specifies the types of metrics (CPU%, memory, network, disk). It distinguishes from status and other VPS tools 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 implies use for retrieving metrics but does not provide explicit when-to-use or when-not-to-use guidance. No alternatives mentioned, though context from sibling tools suggests no other metrics tool exists.

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

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

Without annotations, the description discloses critical behaviors: password is shown once, reveal is not spent until a password is returned, password_pending/password_available flags, SSH key vs password login, NAT port forwarding, and firewall caveats. It also mentions response fields like internal_port and firewall_note.

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?

Despite its length, every sentence carries unique operational value. The description is front-loaded with the core purpose, then details password behavior, then NAT specifics, with 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?

For a tool with no output schema, the description richly describes expected response fields (password_pending, password_available, ssh_ready, internal_port, firewall_note) and covers edge cases (keyless VPS, SSH key provisioning, NAT plans). It also integrates with sibling tools in the workflow.

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 compensates by thoroughly explaining the reveal parameter: one-time reveal, retry timing, and interaction with password_available. The service_id parameter is implicitly identified as the VPS identifier through 'one VPS' context.

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

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

The description opens with a specific verb and resource: 'Get full detail for one VPS: status, specs, live VM state/uptime, and SSH access info'. It also lists unique features like root password retrieval, clearly distinguishing it from sibling tools like list_vps and get_vps_metrics.

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 specifies when to use the tool: poll after order_vps to watch provisioning, and use reset_password only if password is lost. It also explains when to pass reveal and how to handle booting states, providing clear action-oriented 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 burden. It describes the purpose adequately for a simple read operation, but does not disclose additional behavioral traits like data freshness or side effects.

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

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

The description is a single, concise sentence that is immediately understandable. No wasted words or 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 no parameters, no output schema, and is a simple list operation, the description is fully complete. It adequately explains what the tool does without requiring further elaboration.

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 already covers structure. The description adds meaningful context by specifying the resource as 'services delegated by other owners', which is beyond the empty schema.

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

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

The description clearly states the tool lists services delegated to the user, using specific verbs and resources. It distinguishes from siblings like list_delegations (outgoing) and list_vps (owned VPS).

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 viewing incoming delegations but lacks explicit guidance on when to use alternatives like list_delegations or list_vps. No exclusions or conditions 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?

No annotations are provided, and the description does not disclose behavioral traits beyond the basic operation. It does not mention whether it lists only active delegations, pagination, authentication requirements, or any side effects. For a simple read operation, this is adequate but not 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 sentence that is concise and front-loaded with the action and resource. It contains no fluff and earns its place.

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

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

Given the tool has no parameters and no output schema, the description is complete enough for an agent to understand what it does. It explains the scope (outgoing delegations) and the information returned (who, what, status). Slightly more detail about return format or status values could improve it, but it's 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?

The tool has 0 parameters, so the input schema is trivially covered (100%). The description adds no parameter information, which is acceptable per the baseline of 4 for tools with no 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 lists outgoing delegations granted by the owner, specifying 'who has operator access to what, and its status.' It distinguishes from the sibling 'list_delegated_to_me' which lists delegations received, so the agent can differentiate.

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

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

The description implies usage for listing one's own delegations but does not explicitly state when to use this tool versus alternatives like 'list_delegated_to_me' or other sibling tools. No exclusions or context 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?

Discloses that no authentication is needed and implies no side effects. Lacks mention of potential pagination or ordering, but given zero parameters and simple catalog nature, minor omission.

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

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

Two sentences, front-loaded with purpose and immediately followed by actionable usage guidance. 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?

Provides high-level description of output (pricing, specs, OS images). Without output schema, could be more specific about structure, but sufficient for a listing tool with no parameters.

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

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

No parameters, schema coverage 100%. Description adds no parameter details, but baseline score of 4 is appropriate as there is nothing to clarify.

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 available VPS plans with pricing, specs, and OS images, and explicitly distinguishes its role as a catalog for selecting product slug and os_id prior to ordering.

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?

Directly states 'Use this first to pick a `product` slug and an `os_id` for `order_vps`, providing explicit guidance on when and how to use the tool relative to a sibling 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, the description carries the burden of behavioral disclosure. It offers a useful detail about interpreting `last_message_author: "staff"` and implies read-only access via the verb 'list,' but it does not address authorization, pagination, or other behavioral nuances.

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

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

The description is two concise sentences. The first states the action and output, and the second adds a meaningful data interpretation note, with 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?

For a simple parameterless list tool with no output schema, the description covers the key returned fields (status, last-message) and a helpful caveat. However, it omits potential details like response size limits or whether filters exist, so it is 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 tool has zero parameters, so the description correctly avoids parameter details. The baseline of 4 applies for parameterless tools, and the schema already fully covers parameter structure.

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 'List your support tickets with status and last-message info,' using a specific verb and resource. It differentiates from siblings like get_ticket (single ticket) by implying an aggregate list of all relevant tickets.

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 viewing all support tickets, but it does not explicitly mention when to use this over alternatives like get_ticket or reply_ticket. 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?

With no annotations, the description carries full burden. It discloses that deleted/cancelled are excluded and what to do if a server is missing. While it implies read-only behavior, it doesn't explicitly state no side effects, but it's sufficient for agent decision-making.

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

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

Two sentences, no filler, all information is critical. Highly front-loaded with the key purpose and then usage tips.

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 no parameters and no output schema, the description fully covers the return set, exclusions, and downstream usage. An agent has all needed information to decide when to call and how to use results.

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, and schema coverage is 100%. The description adds value by clarifying what the tool returns (active servers and their ids) and how to use the returned data, which exceeds 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 clearly states the tool lists ACTIVE VPS services (active, provisioning, suspended) and explicitly excludes deleted/cancelled. This distinguishes it from sibling tools like get_vps_status or get_vps_metrics, which operate on individual servers.

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

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

The description provides explicit guidance: use the id as service_id for management tools, and if a server is missing, it has been deleted—do not query its status. This helps the agent decide when to use this tool and when to avoid further 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?

Describes return value and usage of token, but lacks disclosure of side effects (e.g., rate limiting, account locking) especially given no 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 clear sentences, no fluff, efficiently conveys core action and response usage.

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

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

Covers basic purpose and token usage, but lacks error handling, prerequisites, or behavioral details. Adequate for a simple login but not comprehensive.

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

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

Schema coverage is 0%, so description must compensate. Merely restates 'email + password' without adding format or constraints beyond what 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?

Clearly states verb (login) and resources (email, password, token). Distinguishes from siblings as the sole authentication 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?

Implied usage as authentication step, but no explicit when-to-use or comparisons to alternatives like register_account or reset_password.

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?

Despite no annotations, description fully discloses two possible outcomes (immediate provisioning vs. payment required) and references subsequent actions. No hidden side effects; behavior is 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?

Three compact paragraphs: first covers core parameters, second optional ones with recommendation, third branching logic. Every sentence earns its place 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?

With no output schema, description covers response structure (paid_from_balance flag, invoice) and references related tools. Complete for ordering a VPS with payment handling.

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

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

With 0% schema coverage, description compensates by explaining product as plan slug from list_plans, os_id as OS id from plan images, ssh_key as public key (recommended), and hostname as optional. Adds critical meaning.

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

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

The description clearly states it orders a VPS, specifies required parameters (product, os_id) and optional ones, and distinguishes from sibling tools like list_plans and get_vps_status.

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

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

Provides explicit branching logic based on response (paid_from_balance true/false), instructing polling status or paying invoice/top-up. Recommends using ssh_key. Clear when and how to use, including post-order steps.

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

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

Discloses return of checkout_url and automatic settlement, but doesn't cover errors or idempotency.

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

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

Two sentences, no fluff, front-loaded with action and result.

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

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

Covers action, return, and side effects adequately for a simple tool; missing error handling details.

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

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

No description for the invoice_id parameter despite 0% schema coverage; description doesn't elaborate on its meaning even though it's inferable.

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

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

Clearly states it initiates payment for an owned unpaid invoice, distinguishes from siblings like topup_balance.

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

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

Implicitly requires invoice to be owned and unpaid, but lacks explicit when-not-to-use or alternatives.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It fails to mention side effects (downtime, disruption), idempotency, synchronicity, error cases, or required permissions.

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?

Extremely concise: one sentence with backtick formatting for actions. However, it sacrifices necessary detail for brevity. Every word earns its place, but the tool could benefit from a bit more context.

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

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

No output schema, no annotations, and the description does not explain return values, error handling, or whether actions are asynchronous. The tool is incomplete for an agent to use reliably without additional documentation.

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% for parameter descriptions. The action enum is self-explanatory, but service_id lacks any explanation of how to obtain it or its meaning beyond 'positive integer'. The description adds no semantic value beyond the schema.

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

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

The description clearly states the verb 'Power-control' and the resource 'a VPS', and explicitly lists the three possible actions: start, stop, or reboot. This distinguishes it from siblings like get_vps_status (read-only) and reinstall_vps (different 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?

No guidance on when to use this tool versus alternatives (e.g., reboot vs stop then start), no prerequisites mentioned (e.g., VPS must exist), and no context about ordering or constraints.

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 explains the return value (bearer token) and how to use it, and notes the lack of a password step. However, it does not disclose potential side effects (e.g., duplicate email handling) or error conditions.

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 unnecessary words. It is front-loaded with the core purpose and includes essential follow-up information about the token.

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 lack of annotations and output schema, the description covers the basic purpose and token handling, but it omits details about error responses, prerequisites, and whether duplicate emails are allowed. Adequate for a simple creation tool but not fully comprehensive.

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

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

The description lists the three parameters (first_name, last_name, email) but adds no additional meaning beyond their names. Schema description coverage is 0%, so the description partially compensates but does not explain constraints like minLength or email 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 clearly states the action ('Create a new EQVPS customer account') and specifies the required fields (first_name, last_name, email). It is distinct from sibling tools like 'login' which handle existing accounts.

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 is for new customer registration by stating 'No password or human step needed', but does not explicitly tell when to avoid using it (e.g., if the user already has an account) or suggest alternatives like 'login'.

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 fully bears the burden of disclosure. It clearly declares the tool as 'DESTRUCTIVE — all data is lost', mandates human confirmation, and explains the asynchronous nature and polling requirement. This is comprehensive and leaves no ambiguity about the tool'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 three sentences long, with the first sentence delivering the most critical warning upfront. Every sentence provides essential information without redundancy or fluff. It is well-structured for quick comprehension.

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

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

Given the tool's complexity (destructive, async) and the absence of an output schema, the description covers key aspects: the destructive nature, the confirmation requirement, how to obtain os_id, and the need to poll status. It does not mention error handling or the source of service_id, but the provided context is sufficient for safe usage.

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

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

The schema description coverage is 0%, but the description adds meaning for two of the three parameters: os_id (from list_plans) and confirm (exact hostname or 'DELETE'). The service_id parameter is not explained, though its purpose as the VPS identifier is somewhat inferable from context. The description partially compensates for the lack of schema descriptions but is not exhaustive.

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: 'Wipes and reinstalls the VPS with the given OS image'. It uses a specific verb ('reinstall') and resource ('VPS'), distinguishing it from sibling tools like 'power_vps' or 'set_hostname' which perform different operations.

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

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

The description provides explicit guidance: it requires human confirmation ('Agent must explicitly confirm') and defines the format of the 'confirm' parameter (exact hostname or 'DELETE'). It also mentions asynchronous behavior and polling. However, it does not explicitly state when not to use this tool or suggest alternatives for less destructive 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 bears full responsibility for disclosing behavior. It only says 'post a reply', which implies a write operation, but does not mention side effects such as email notifications, status changes, or whether the reply is visible to the customer. It also omits any authentication or ownership requirements beyond 'one of your tickets'.

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

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

Two short sentences, front-loaded with the action 'Post a reply' and containing no redundant information. Every word adds value.

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

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

For a simple two-parameter action without output schema or annotations, the description covers the core action and the source of the identifier. However, it lacks details about expected behavior, return values, or errors, which could be important for an agent invoking the tool autonomously.

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 no descriptions for the two parameters (0% coverage). The description compensates partially by explaining that ticket_code should be obtained from create_ticket or list_tickets, but it gives no additional meaning for 'message' beyond being a reply.

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 'reply' and clearly identifies the resource as a support ticket. It distinguishes the tool from siblings like create_ticket, close_ticket, and list_tickets by specifying the reply action, and it names the required input source.

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 context for when to use the tool: to post a reply on an existing ticket, and explicitly specifies that the ticket code must come from create_ticket or list_tickets. It doesn't mention exclusions or alternatives, but the usage 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?

Since no annotations are provided, the description carries full burden and excellently discloses behavioral details: the password is applied live without reboot, effective in 10-30s, the old password stops working, and the new password is not in the response but must be read once via get_vps_status. It also reveals the confirm requirement and the emailing of the password, giving a complete picture of side effects and post-conditions.

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 dense but well-organized, leading with the core purpose and then layering behavioral, parameter, and usage information. While it is somewhat long, each sentence conveys essential operational details (e.g., immediate application, no reboot, required confirm format, human confirmation, alternative approach for fresh orders, password retrieval method). The structure is logical and front-loaded, with only minor redundancy in the urgency of human confirmation.

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 full operational context: when to use, prerequisites (confirm exact hostname), side effects, post-call steps to retrieve the password, and alternative tools for similar situations. It even handles the edge case of a fresh VM boot delay. With no output schema and no annotations, this description alone provides enough information for an agent to correctly execute and handle the tool's outcomes.

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 adds substantial meaning to the confirm parameter by specifying it must be the exact hostname from get_vps_status or 'DELETE'. However, service_id is not explicitly described, though its role as the VM identifier is implied by the context. Given the schema has no descriptions (0% coverage), the description compensates well for confirm and partially for service_id, resulting in a strong but not perfect score.

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

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

The description opens with a specific verb+resource: 'Rotate the root password.' It clearly states the function and distinguishes it from sibling tools by specifying the live VM context and the guest-agent mechanism, setting it apart from related tools like set_hostname or reinstall_vps.

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

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

The description explicitly states when to use this tool ('Use this ONLY if the password was lost') and when not to use it (not for SSH not being instant on a fresh order), offering a specific alternative: poll get_vps_status with reveal:true. It also mandates human confirmation before calling, providing clear procedural 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 provided, so description carries full burden. Mentions notification to the other side and two scenarios. However, does not disclose idempotency, error handling, or authorization requirements (e.g., who can revoke). Adds some value but leaves gaps.

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

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

Two sentences, front-loaded with the core action, no fluff. Every sentence serves a purpose: definition, notification, and guidance on finding the id.

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

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

Tool is simple (1 param, no output schema). Description covers action, use cases, notification, and id retrieval. Missing details on result, idempotency, or permissions, but adequate for straightforward revoke 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 0%, and description does not compensate well. Only states 'by its id' without explaining the parameter's meaning, format, or source directly. Relies on name 'delegation_id' being self-explanatory, but more detail would help.

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

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

Clearly states the action (revoke), resource (delegation), and two specific use cases (owner revokes, delegate declines). Distinguishes itself from sibling tools like accept_delegation and list_delegations.

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 tells the user to use list_delegations/list_delegated_to_me to find the delegation id, providing a clear precondition for usage. Lacks explicit when-not-to-use guidance, but the context is straightforward.

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

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

The description discloses that the hostname is applied on next reboot/rebuild, which is critical behavioral information beyond annotations (none provided). Minor omission: no mention of side effects or required VPS state.

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 sentence with clear front-loading: 'Set the VPS hostname' immediately conveys purpose. No extraneous 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?

Adequate for a simple tool with two parameters and no output schema. The description covers the core action and timing but leaves questions about prerequisites and validation rules.

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 description must compensate. It adds 'valid DNS label' for hostname but does not explain service_id (presumably VPS ID). Missing semantics for half 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 the tool sets a VPS hostname, with a specific verb and resource. It distinguishes from sibling tools which perform different operations like canceling or powering VPS.

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 like reinstall_vps or power_vps. The description does not mention prerequisites or context, leaving the agent to infer usage.

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 discloses key behaviors: creating an invoice, returning a checkout URL, automatic credit on confirmation, and server-side min/max enforcement.

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

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

The description is three concise sentences, front-loading the main action and adding necessary constraints 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 single-parameter tool with no output schema, the description covers the core workflow, constraints, and output, though it omits error handling details.

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

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

The schema has 0% description coverage for the 'amount' parameter, but the description adds crucial semantics: currency is USD, and min/max are enforced server-side.

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

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

The description clearly states that the tool creates a top-up invoice and returns a checkout_url for PayRam crypto checkout. It specifies the credit automation, currency (USD), and server-side enforcement of 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 mentions the 'only one unpaid top-up at a time' constraint but does not explicitly guide when to use this tool vs alternatives like 'pay_invoice' or other billing 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 bears the full burden. It discloses that the tool returns profile data and can verify token validity. No side effects are implied, and the description is accurate and 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 concise sentences, front-loaded with the main action and followed by usage guidance. 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 no-parameter tool with no output schema, the description is complete: it states what it returns, the purpose, and a use case. Sibling tools are diverse, and this stands alone.

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 value by specifying the return fields (id, name, email), compensating for the lack of an output schema.

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

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

The description clearly states the tool returns the authenticated account profile with specific fields (id, name, email). It uses a specific verb and resource, and the tool is distinct from siblings like 'login' or 'get_balance'.

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

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

The description explicitly states when to use the tool: 'to verify the bearer token is valid.' This provides clear context, though no exclusions or alternatives are mentioned, which is acceptable for a simple self-identity tool.

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