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

Adds substantial context beyond the annotations: the order is placed unpaid and enters the translation queue, payment is handled separately, and the call is refused when the key's spending limits are exceeded. This complements idempotentHint=true (reassured by the request_id note) and destructiveHint=false without contradicting them.

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

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

Four sentences, no filler, and the critical confirm=false-first instruction is front-loaded. Every sentence carries either the flow, the state transition, the payment path, or the failure condition.

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, the description still tells the agent what the preview contains (price, delivery, files), what state the order lands in (unpaid, queued), and how to complete payment. Nothing an agent needs to invoke or continue the workflow is missing.

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

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

Schema coverage is 92%, so most parameter meaning is already documented. The description nonetheless adds procedural semantics for confirm and request_id (preview-then-confirm, retry safety) and the preview contents, going beyond the field-level text.

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?

States a specific verb and resource ('Place a certified translation order') plus scope ('for this account with the uploaded files'). It is clearly distinguishable from siblings like get_quote, pay_order, and order_status, which cover quoting, payment, and tracking rather than order creation.

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

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

Gives an explicit two-step protocol: call with confirm=false and show the preview, then call again with confirm=true and a request_id. It also names the follow-up alternatives, pay_order or sharing the payment link, so the agent knows what to do after this tool returns.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety is covered. The description still adds real context: the link only makes sense for an unpaid order, it supports card or PayPal, and it may be needed for cardholder approval. Minor gap: no note on link expiry or repeatability.

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 no filler; the core noun phrase comes first and the usage cases follow. The trailing clause is slightly convoluted ('to send to whoever pays') but still 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?

With no output schema, the description usefully states what is returned (a web link) and the two situations it applies to. Complete enough for an agent to call it correctly, missing only details about link lifetime or validity of the unpaid order.

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

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

Schema coverage is 100% and the single order_number parameter is documented with a format example in the schema itself. The description adds nothing about the parameter, so the baseline 3 applies.

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

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

States a specific verb and resource ('the web link where anyone can pay an unpaid order') and pins the scope to unpaid orders, which implicitly separates it from pay_order and order_status. It never names a sibling explicitly, so differentiation rests on inference.

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

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

Gives two concrete use contexts: sending the link to whoever pays (e.g. the firm's client), or when a card needs the cardholder's approval. That is clear when-to-use guidance, though it offers no when-not-to-use or explicit alternative 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 establish readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely new behavior: account-specific discount and rush are auto-applied, other turnarounds are returned for comparison, and it reports whether the key's spending limits permit the order.

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?

Compact: one dense sentence on the returned content plus a short negating sentence that is well placed. The parenthetical about team discount and rush is slightly crowded, but nothing is wasted.

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?

There is no output schema, so the description usefully enumerates what comes back (price, delivery time, comparison turnarounds, spending-limit eligibility) for a single-purpose read tool with only one required parameter. Missing only response-format detail, which is a minor gap.

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

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

Schema description coverage is 100%, including enum semantics for turnaround and the pages-vs-upload_ids interaction, so the description does not need to carry parameter meaning. It adds no syntax or format detail beyond the schema, which is the expected baseline of 3.

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

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

States a specific resource (price + delivery time for a certified translation) and scopes it to this account with team discount and included rush applied. The closing 'Nothing is ordered' implicitly separates it from the mutating siblings (create_order, pay_order, order_status), though no sibling is named directly.

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?

'Nothing is ordered' makes the use context clear: this is a pre-purchase preview to consult before committing. It does not explicitly name the alternative tools (e.g., get_payment_link or create_order) or state when-not to use it, so it stops short of a 5.

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

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

Annotations already declare this is read-only, idempotent, non-destructive, and not open-world, so the safety profile is fully covered. The description adds useful content context (that it returns requirement details, not just a name list), but says nothing about caching, freshness, or that results are static reference material.

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 dense sentence, front-loaded with the core resource and then elaborating returned content. The parenthetical example list adds scannability without wasting much space, though the trailing requirements clause is slightly run-on.

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 reference lookup with full annotation coverage and no output schema, the description adequately conveys what the agent will get back. A brief note on output shape or how it relates to upload_document would make it 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 takes zero parameters, so there is nothing to document; baseline is 4. The description correctly implies a parameterless, global reference listing rather than a filtered query.

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?

States a specific verb (List) and resource (document types) plus the scope of what's returned: the types themselves, per-type upload guidance, and general requirements. It is clearly distinguishable from siblings like list_languages or list_my_orders, and no other sibling enumerates document type guidance.

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 a reference lookup to consult before uploading documents, but it never says when to call it versus e.g. upload_document or get_quote, nor states any preconditions. Usage is inferable from the content listed but not explicitly guided.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond that — it discloses the shape of each returned record (code, two price figures, surcharge flag, expedited coverage) and that prices are quoted relative to English and another language.

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

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

A single front-loaded sentence that leads with the resource and then stacks the returned fields. It is dense but every clause carries information about the return payload; no filler or restatement of the title.

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 no parameters, the description carries the full burden of explaining the response, and it does so by naming each returned field. It stops short of stating the exact format of the price values or the surcharge flag type, which is a minor residual gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies. No parameter guidance is needed or missing.

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?

States a specific verb+resource ('The languages eVerbary translates') and enumerates exactly what each entry carries: codes, per-page price, surcharge flag, and Expedited Plus coverage. An agent can distinguish it from the sibling list_document_types purely from the text.

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

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

The phrase 'the codes the other tools take' implies this is the lookup an agent should call before create_order or get_quote, but there is no explicit when-to-use statement, no named alternative, and no exclusion. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds only the scoping ('this account') and the returned field set; it says nothing about page size behavior, ordering guarantees, or truncation, which is a modest addition given the annotation coverage.

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

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

A single front-loaded sentence with zero filler; every clause earns its place by naming the scope and the surfaced fields.

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, the description usefully enumerates what each order carries (status, price, payment state), and the schema covers both params. It stops short of explaining ordering or the relationship to the order_status sibling, but is otherwise sufficient for a simple two-param list tool.

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

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

Schema description coverage is 100% – both limit ('How many, newest first.') and status ('Only these: open/delivered/...') are already documented in the schema. The description adds no parameter syntax or format detail, so baseline 3 applies.

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

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

States a specific verb+resource ('this account's most recent orders') and enumerates the fields surfaced (status, price, payment state). It implicitly contrasts with siblings like order_status and create_order, though it never names them explicitly.

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 is only implied by the phrase 'most recent orders' – no explicit when-to-use, no note on how it differs from the single-order order_status sibling, and no pagination guidance. Adequate but with clear gaps.

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 readOnly, idempotent, and non-destructive, so safety is covered. The description adds genuinely useful context beyond that: results are limited to this account's orders, and it discloses the return contents (payment state options including 'on account' with invoice, and links to certified translation files once delivery occurs). It does not cover failure behavior for an unknown or foreign order number.

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 dense sentence that front-loads the resource and then the returned fields. Nothing is wasted, though the parenthetical payment enumeration makes it list-heavy rather than crisp.

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, the description usefully describes what the call returns, including payment semantics and delivery-file links, and notes account scoping. It leaves undefined what happens for an invalid or non-owned order number, which is the main remaining gap for a single-parameter lookup.

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 one parameter at 100% schema description coverage, the schema already documents order_number fully, including the example '43392' and range bounds. The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

The description names a specific resource (one of this account's orders) and enumerates what status comprises: progress, expected delivery, payment state, and delivery-file links. It does not explicitly contrast with the sibling list_my_orders, so a reader must infer the singular-vs-list distinction from 'one of this account's orders'.

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 when-to-use statement, no prerequisites, and no mention of the obvious alternative (list_my_orders) or how to obtain a valid order number. Usage is only implied by the required order_number and the account-scoping phrase.

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 destructiveHint=true, idempotentHint=true and openWorldHint=true, and the description adds substantial context beyond them: card numbers are never accepted, nothing is charged when 3-D Secure approval is needed (a payment link is returned instead), the confirmation_id is valid 15 minutes, retries never double-charge, and there are per-order and per-day limits for the key.

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?

Front-loads the core action and funding methods, then the mandatory confirm-then-charge sequence, then edge cases (3-D Secure) and limits. Four sentences, no filler, and each sentence carries distinct operational 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?

No output schema exists, and the description covers the important return behavior (payment link on 3-D Secure challenge) and the confirmation_id round-trip. It does not describe the general success response shape or where the confirmation_id surfaces from the confirm=false call, but for a mutation tool with rich annotations and full schema coverage this is nearly complete.

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

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

Schema coverage is 100% so the baseline is 3, but the description goes beyond field definitions by framing the parameters as a two-step workflow (confirm=false yields the confirmation_id that confirm=true consumes) and by explaining the off-session nature of card_on_file. The enum values themselves are already fully described in the schema, so this is reinforcement plus flow context rather than new per-parameter detail.

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

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

States a specific verb+resource ('Pay an order') and immediately enumerates the three funding sources the account can use (prepaid balance, saved card off-session, periodic invoice), which distinguishes it from sibling tools like get_payment_link or get_quote. An agent can identify the tool's job without opening the schema.

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?

Gives an explicit required sequence: call with confirm=false, show the user amount and method, then confirm=true with the confirmation_id, plus the 3-D Secure branch behavior. It never states when NOT to use it or names an alternative sibling (e.g. get_payment_link) as the right tool in some condition, so it falls short of a full 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 declare readOnlyHint=false, destructiveHint=false, idempotentHint=true and openWorldHint=true. The description adds genuinely useful behavior beyond that: a 24-hour retention window and the concrete idempotency semantics (re-sending the same file yields the same upload_id). It omits failure modes and size limits, but the retention/idempotency detail is real added value.

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

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

Three sentences, zero padding. The primary action and its ordering constraint come first, followed by return values, then retention/idempotency detail – a well front-loaded 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?

There is no output schema, but the description compensates by naming the return values (upload_id, page count) and their consumers. For a 3-parameter upload tool with full annotations, nothing essential is missing.

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

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

Schema description coverage is 100% with all three parameters documented inline (url, filename, content_base64 including size limits). The description only adds acceptable file-format examples, so the schema is doing the heavy lifting – baseline 3 is appropriate.

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

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

States a specific verb and resource (send a source document), the accepted input types (PDF, image, Word), and the returned artifact (upload_id plus page count). It clearly positions itself as a pre-order step, distinguishing it from siblings like get_quote and create_order.

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

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

Tells the agent to upload 'before ordering' and names the downstream tools that consume the upload_id (get_quote, create_order), which gives clear context. It does not state any when-not conditions or alternatives, but for a prerequisite step the sequencing guidance is sufficient.

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