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

With no annotations, the description carries the full behavioral burden for a mutation tool. It does not disclose what happens to the source estimate (deletion, status change), whether the operation is idempotent, what error occurs on a non-accepted estimate, or what the created invoice contains.

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

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

A single front-loaded sentence with no filler that clearly leads with the action and target. It is efficient, though the terseness borders on under-specification for a stateful conversion operation.

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 mutation/creation tool with no annotations, no output schema, and an undocumented parameter, one sentence is insufficient. The agent still lacks the estimate's post-conversion fate, error conditions, and expected return, which are essential for correct invocation.

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

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

Schema description coverage is 0% and the description adds no detail about estimateId beyond the implicit requirement that it reference an accepted estimate. It does not clarify format, valid ranges, or failure behavior for an invalid ID, so it fails to compensate for the undocumented 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?

States a specific verb (Convert) and the concrete resource transformation (accepted estimate → invoice), which lets an agent distinguish it from siblings like create_invoice. However, it does not explicitly name or contrast against create_invoice, so the differentiation is implied rather than stated.

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 'accepted estimate' implies a prerequisite state, giving some guidance about when this tool is appropriate. But it never says when to use this versus create_invoice, nor what to do if the estimate is not yet accepted, leaving the selection logic implicit.

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

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

Annotations are absent, so the description carries the full burden. 'Create a new customer' reveals nothing about whether the operation requires specific permissions, whether it triggers side effects like sending a welcome email, whether duplicate customers are allowed, or what happens on failure. This is critically thin for a mutation tool.

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

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

The single sentence is extremely concise, but it is under-specified rather than efficiently informative. There is no waste, yet the brevity comes at the cost of useful detail.

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

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

For a 4-parameter creation tool with no annotations, no output schema, and sparse schema documentation, the description is wholly inadequate. An agent has no information about required versus optional fields, side effects, or return values.

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

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

Schema description coverage is only 25%: email, phone, and name have no descriptions, and the only parameter documented is currency_id. The description adds no information about expected formats, defaults, or which fields are required, so it fails to compensate for the coverage gap.

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

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

States a clear verb (create) and resource (customer), which is specific enough to distinguish it from get_customer, update_customer, and delete_customer. The description is minimal but unambiguous about what the tool does.

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

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

No guidance on when to use this tool versus alternatives such as update_customer or when a customer already exists. It does not mention prerequisites, required fields beyond the schema, or any conditions under which creation should occur.

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, and it does disclose one genuinely useful behavioral trait: InvoiceShelf's undocumented required fields are handled internally. That is non-obvious and beyond the schema. It still says nothing about authentication, side effects, ID/response shape, or what exactly gets auto-filled.

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 with the purpose front-loaded and no filler. The second sentence earns its place by disclosing internal behavior, though it is cryptic about specifics.

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

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

This is a mutation tool with no annotations, no output schema, and low parameter coverage, so the description should explain permissions, effects, and return value. It omits all of these, leaving an agent without the context needed to call it confidently.

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

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

Schema description coverage is only 43% across 7 parameters, so the description must compensate, but it mentions no parameter semantics at all. The vague note about handling 'undocumented required fields internally' does not tell the agent which fields are auto-populated or how to format the others.

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 ('Create a new estimate'), which distinguishes it from sibling create_invoice and from read/update/delete estimate tools. However, it offers no explicit differentiation from create_invoice or convert_estimate_to_invoice, so routing relies on the resource noun alone.

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

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

No when-to-use guidance and no mention of alternatives such as create_invoice or convert_estimate_to_invoice. The agent is left to infer that this is the entry point when a new estimate is needed and that nothing else should be used.

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 behavioral burden. It discloses one genuinely useful trait – that InvoiceShelf's undocumented required fields are filled in internally – but says nothing about permissions/authentication, whether the created invoice is sent or left as a draft, idempotency, or what happens on validation failure.

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 tight sentences with the action front-loaded and no filler. It is appropriately sized, though the second sentence is doing more implicit work than its length suggests.

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?

A mutation tool with no annotations, no output schema, and only 50% parameter description coverage. The description should state at least whether the invoice is created as draft or sent, and what is returned (id, invoice_number), but it leaves these to inference.

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

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

Schema coverage is 50%, so the description should compensate for the undocumented half of the parameters (items.name/quantity/description, notes, reference_number) and add meaning beyond the schema. It adds none; the schema already documents the tricky parts (price units, date format, template_name default, invoice_number auto-generation).

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 ("Create a new invoice") that is unambiguous within the invoice/estimate/customer tool family. It does not explicitly contrast itself with siblings like create_estimate or convert_estimate_to_invoice, but the create semantics are clear enough for selection.

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 when-to-use guidance, no prerequisites, and no mention of alternatives (e.g. create_estimate vs convert_estimate_to_invoice). The only weak signal is that undocumented required fields are handled internally, which implies the caller needn't supply extra data, but this is not framed as usage 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 the full behavioral burden for a destructive operation. It says nothing about irreversibility, whether related records (invoices, estimates) are cascaded or orphaned, required permissions, or failure behavior when the ID does not exist.

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

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

One short, front-loaded sentence with no wasted words, which is structurally clean. But the terseness is under-specification rather than discipline for a destructive tool, so it is only marginally appropriate sizing.

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?

A destructive mutation with no annotations, no output schema, and an undocumented parameter needs the description to cover consequences and side effects, and it covers none. An agent cannot safely predict what happens after this call.

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

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

Schema description coverage is 0% and the single parameter is undocumented in the schema. The description only echoes 'by ID', which implies the numeric customerId is the lookup key but adds no format, range, or source-of-truth detail beyond the property name.

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 ('Delete') and resource ('a customer'), so an agent can tell it apart from delete_invoice and delete_estimate by resource. It does not, however, contrast itself with any sibling or explain scope (e.g., whether deleting a customer affects their invoices), so it falls short of the top band.

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

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

The description gives no when-to-use guidance, no prerequisites, and no exclusions. With siblings like get_customer, update_customer, and delete_invoice in the same namespace, an agent gets no help deciding when this is the right call or what should happen first.

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 behavioral burden. It does not state whether deletion is permanent, whether it requires elevated permissions, what happens to estimates already converted to invoices, or whether related line items are removed. For a destructive operation, this is a significant disclosure 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?

A single short sentence that is front-loaded with the verb and resource, with no filler. Its brevity reflects under-specification rather than wasted words, but structurally it is efficient.

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

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

For a destructive tool with no annotations, no output schema, and an undocumented parameter, the description is too thin. It does not tell the agent what a successful call returns or what side effects to expect.

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

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

Schema description coverage is 0% and the single parameter (estimateId) is only a bare number. The description's 'by ID' hints at the identifier but adds no format, source, or validation details (e.g., where to obtain the estimateId), so it only minimally compensates for the schema gap.

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

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

The description states a specific verb ('Delete') and resource ('an estimate'), so the agent knows exactly what action is performed. It does not, however, differentiate itself from siblings like delete_invoice, delete_customer, or update_estimate beyond the resource name.

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

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

There is no guidance on when to use this tool versus alternatives (e.g., could an estimate be archived or voided instead?), and no mention of prerequisites such as ownership or confirmation. The agent must infer all usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. For a destructive tool, it omits critical details: permissions required, whether the delete is permanent or reversible, side effects on related data, and confirmation requirements. The description is a bare restatement of the name.

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 short sentence, front-loaded with the action. However, it is too terse for a destructive operation, leaving essential context unstated.

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?

A destructive tool with no annotations, no output schema, and only a one-line description is grossly inadequate. It should disclose irreversibility, permissions, and what happens to linked records.

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%, but with only one required parameter (invoiceId) and a simple type, the description's 'by ID' implies the parameter's purpose adequately. Baseline for a single generic param is 3 when schema is minimal.

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 (Delete) and resource (invoice) with its identifier reference. It is distinguishable from sibling tools like get_invoice or update_invoice, though 'by ID' is generic and doesn't clarify if it's soft/hard delete or recursive.

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., delete_estimate, deactivating an invoice). No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic operation, omitting important context such as required permissions, what 'full details' includes, error handling for missing IDs, or response format. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that conveys the essential action. It is front-loaded with the verb and resource, leaving no room for waste.

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

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

Given the lack of annotations, 0% schema description coverage, and no output schema, the description is incomplete. It doesn't explain what 'full details' entails, whether the ID is numeric, or how errors are handled, leaving the agent under-informed for invocation.

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

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

Schema coverage is 0%, so the schema lacks parameter descriptions. The description mentions 'by ID' but doesn't explain the customerId parameter's format, expected type (number vs string), or how to obtain it. It fails to compensate for the schema's lack of 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?

The description states a clear verb (Get) and resource (customer), and specifies retrieval by ID for a single record. It's distinguishable from list-oriented siblings like get_customers, though it doesn't explicitly differentiate from update_customer or delete_customer beyond the verb.

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

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

The description implies usage when needing full details for a specific customer, but provides no explicit when-to-use guidance or alternatives like get_customers for listing. No mention of prerequisites or error conditions.

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 behavioral burden. 'Get all invoices' usefully signals a complete, read-only listing, but nothing is said about pagination, ordering, whether archived/void invoices are included, or permission requirements.

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

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

A single front-loaded sentence with no filler; the scope and the optional filter are both stated immediately. 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?

With no annotations and no output schema, the description is the only guidance an agent gets. It covers the core action but leaves return shape, pagination, and status values unaddressed, which is thin for a list tool in a large invoice-tool family.

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

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

Schema description coverage is 0%, so the description must compensate. It does convey the meaning of both parameters conceptually (customerId selects the customer, status filters the results), but offers no format guidance and does not enumerate the accepted status values.

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

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

States a clear verb and resource ('Get all invoices for a specific customer') with an explicit scope qualifier. It implicitly separates itself from the sibling get_invoices by scoping to one customer, but never names that sibling, so an agent must infer the distinction.

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

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

The phrase 'for a specific customer' plus the optional status filter implies when this tool applies, but there is no explicit statement of when to prefer it over get_invoices or get_invoice, nor any prerequisites. 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?

No annotations are provided, so the description carries the full behavioral burden. It hints that pagination and search are optional but discloses no defaults, page-size limits, sorting behavior, authentication needs, or return shape — significant gaps for an unannotated list tool.

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

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

A single front-loaded sentence with no filler; efficient, though its brevity is partly under-specification rather than disciplined concision.

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 annotations, no output schema, and 0% schema description coverage, the description leaves too much unspecified for an agent to call this tool confidently — no defaults, no result format, no guidance on the search parameter.

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

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

Schema description coverage is 0%, so the description must compensate for the three parameters. It only maps them loosely to concepts ('pagination', 'search') and adds no format, default, range, or matching semantics (e.g., which customer fields 'search' targets).

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

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

The description states a specific verb ('List') and resource ('customers'), which distinguishes it from the singular get_customer and the write-oriented siblings like create_customer. It does not, however, explicitly name or differentiate itself from those siblings in the text itself.

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

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

There is no guidance on when to use this tool versus get_customer (single record) or get_customer_invoices. The word 'List' implies a bulk/collection operation, but no conditions, prerequisites, or alternatives are 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?

With no annotations, the description carries full behavioral burden. 'Get' implies a read, but it says nothing about aggregation scope, permissions, date range, or cost/latency of the summary operation.

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

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

A single tight sentence with no waste, front-loading the purpose. The trailing 'etc.' slightly weakens the specificity of the enumerated stats.

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

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

For a parameterless read tool this is nearly complete, but with no output schema the description only partially conveys the return shape ('totals due, paid, overdue, etc.'), leaving the actual metric set ambiguous.

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

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

There are zero parameters and schema coverage is 100%, so the baseline of 4 applies; there is no parameter information the description could add.

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 (Get) and resource (dashboard summary stats) and enumerates the content (totals due, paid, overdue). It is implicitly distinct from the invoice/customer CRUD siblings, though it never explicitly contrasts itself with them.

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

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

No indication of when to use this versus the list/aggregate siblings like get_invoices or get_customer_invoices, and no prerequisites or context (e.g., time window) are given.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation and a complete (unpaginated) record via 'full details', but says nothing about permissions, behavior on a nonexistent/invalid ID, or what the response contains.

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

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

One short sentence, front-loaded with the verb and resource, with zero filler. Nothing could be removed without losing meaning.

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

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

For a simple single-record lookup with no output schema and no annotations, the description is minimally adequate, but it leaves the meaning of 'full details' and the failure mode for a bad ID unspecified.

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

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

Schema description coverage is 0% and the single required estimateId parameter has no schema description. The phrase 'by ID' only tells the agent the number is an estimate identifier; no format, source, or validity constraints are added.

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 (Get), resource (estimate), scope (single, by ID), and outcome (full details). The word 'single' implicitly distinguishes it from the sibling get_estimates, though the sibling is not named 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: use this when you have an estimate ID and want the complete record rather than a list. There is no explicit when-to-use, no mention of get_estimates as the list alternative, and no prerequisites 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?

With no annotations, the description carries the full behavioral burden and does not meet it. 'List' implies read-only, but there is no mention of pagination defaults, maximum limits, result ordering, or whether pagination is applied when omitted — all material for a listing endpoint.

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

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

A single well-formed sentence with the resource and the filter scope front-loaded. Nothing is wasted, though it is arguably too terse to earn a top score given the tool's parameter surface.

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, so the description could reasonably say what the listing returns, and no annotations, so it could state the read-only/safety profile. For a simple 4-param list endpoint the coverage is minimally adequate, but pagination and return shape are left open.

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% across 4 parameters, so the description must compensate. It roughly maps to all four parameters — pagination (page/limit), search, and customer filters — which is the minimum needed, but gives no formats, defaults, or matching semantics, so the agent still guesses at values.

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

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

The description states a specific verb ('List') and resource ('estimates'), and names the filter categories, which cleanly separates it from the singular get_estimate sibling. It stops short of explicitly naming or contrasting alternatives, but the purpose itself is unambiguous.

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

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

The only usage signal is that filters are 'optional' — there is no statement of when to reach for this tool versus get_estimate, get_estimates-by-customer, or the search-style siblings, and no exclusions. An agent can infer this is the browse path, but nothing is explicit.

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

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

No annotations are provided, so the description carries the full burden. 'Get' reasonably implies a read-only lookup and 'full details' indicates a complete record rather than a summary, but nothing is said about behavior on an unknown ID, required permissions, or error handling.

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 resource and the lookup key are both stated immediately.

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

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

For a simple, single-parameter getter with no output schema or annotations, the description covers the essential shape of the operation. It could say more about what 'full details' comprises or how a missing invoice is signalled, but nothing an agent needs to select and call it 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 0%, so the description must compensate. 'By ID' confirms invoiceId is the identifier, which adds a little meaning, but its type/format expectations remain undocumented in both schema and description. Adequate but with a clear gap.

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

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

States a specific verb and resource ('Get full details for a single invoice by ID') and the singular scope distinguishes it from the plural siblings get_invoices and get_customer_invoices. It stops short of explicitly naming those alternatives, so it doesn't reach the top of the scale.

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: an agent infers this is for fetching one known invoice by identifier. There is no statement of when to prefer it over get_invoices, get_customer_invoices, or get_invoice's absence of any prerequisite/exclusion conditions.

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 behavioral burden. 'List' implies a read, but it discloses no pagination defaults, page-size limits, sort order, permission scoping, or result shape — all material for a 5-parameter listing endpoint.

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 names the action, the resource, and the four filter families with zero filler. Every clause 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 5-parameter list tool with no annotations and no output schema, the description covers the filter surface but omits pagination defaults, ordering, and any note on how the invoice list is scoped. Minimally adequate, but an agent still has gaps to guess at.

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

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

Schema description coverage is 0%, so the description must compensate. It names pagination, search, status, and customer filters, which maps onto page/limit/search/status/customer_id, but adds no format, default, or enum-value detail beyond the parameter names already visible in the schema.

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

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

States a specific verb (List) and resource (invoices) plus the filter dimensions, so the agent knows this is a collection read. However, it does not distinguish itself from the sibling get_customer_invoices, which also lists invoices and could be confused with this one.

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 says nothing about when to use this versus get_invoice (single record) or the customer-scoped get_customer_invoices. No prerequisites, scope, or exclusions are given, so routing between the list tools is left to inference.

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

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

No annotations are provided, so the description carries full behavioral burden. It says 'Get full details', which implies a read operation, but does not disclose permissions, error behavior, or what 'full details' includes beyond the schema.

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

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

A single, front-loaded sentence with no wasted words. It is appropriately sized for a simple getter.

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

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

For a low-complexity tool with one parameter and no output schema, the description is minimally viable but omits error handling and return shape details. With no annotations, it could do more to inform the agent.

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

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

Schema description coverage is 0% and the single parameter 'userId' has no description in the schema. The description adds only 'by ID', clarifying that the number is an identifier, but does not specify format, constraints, or 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?

States a clear verb ('Get') and resource ('user'), and the phrase 'single user' distinguishes it from the sibling 'get_users' which presumably lists multiple users. However, it does not explicitly name the alternative tool as the high-scoring example does.

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

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

Provides no when-to-use guidance, no prerequisites, and no exclusions. The agent must infer that this tool is for fetching one user by ID versus the list tool 'get_users'.

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. 'List' implies a read operation, but nothing is said about permissions/auth requirements, default page size, ordering, or whether results are paged. For a collection endpoint with zero structured coverage, this is thin.

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 short sentence with no waste, but its brevity reflects under-specification rather than disciplined conciseness. It is appropriately front-loaded but earns little.

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 two undocumented parameters, no annotations, and no output schema, the definition leaves the agent without pagination semantics, auth requirements, or return shape. It is not sufficient for calling the tool correctly beyond a bare request.

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?

Both parameters (page, limit) have 0% schema description coverage and are never mentioned in the description, so the agent gets no semantics for them. It only weakly implies a paginated list, without stating defaults or ranges.

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 (users) scoped to the InvoiceShelf instance, and the plural naturally separates it from the sibling get_user. It does not explicitly name the alternative, but the resource and action are unambiguous.

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

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

There is no guidance on when to call this versus get_user, nor on pagination behavior or how to retrieve a full list. The agent must infer usage entirely from the name.

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, and it does disclose one real behavior: sender address and customer email are resolved automatically rather than passed in. However, it omits side effects (does sending change the estimate's status or record a sent timestamp?), permission requirements, and failure modes such as a customer with no email on file.

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 with no waste, and the core action is front-loaded ahead of the automatic-lookup detail.

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

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

This is an outbound-email mutation with no annotations, no output schema, and 0% parameter documentation, yet the description says nothing about side effects on the estimate record, required permissions, or error behavior. For a send action that cannot be undone, that is a meaningful 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 0%, so the description must compensate and largely does not. It explains why sender/recipient addressing is absent from the parameter set, but estimateId, subject, and body remain undocumented — no format for estimateId, no indication whether subject/body override template defaults or are required.

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 ('Email an estimate to its customer') and adds the destination, so the agent knows exactly what happens. It is distinguishable from the sibling send_invoice by the resource itself, though the description never explicitly contrasts the two.

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 when-to-use guidance, no stated prerequisites (e.g., estimate must already exist or be in an unsent/draft state), and no mention of the send_invoice alternative. Usage is only implied by the verb 'Email'.

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 usefully discloses that the sender address and customer email are looked up automatically (no need to supply them), but omits the permission requirements, the irreversible side effect of actually sending email, and any rate limits or state preconditions.

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 with zero waste; the core action is front-loaded and the helpful auto-lookup detail follows immediately.

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 side-effecting action tool with no annotations, no output schema, and 0% parameter coverage, the description is minimal but covers the core purpose. It leaves preconditions, side-effect behavior, and the subject/body parameters unexplained.

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

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

Schema description coverage is 0%, so the description must compensate, yet it only implicitly identifies invoiceId and says nothing about the optional subject and body overrides. The automatic-lookup note implies sender/customer params are unnecessary but the two remaining parameters are entirely undocumented.

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 ('Email an invoice') and clearly distinguishes itself from siblings like create_invoice, update_invoice, and delete_invoice. An agent can tell this is the send/dispatch action 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?

Usage is implied by the verb 'Email' but there is no explicit when-to-use guidance, no mention of prerequisites (e.g. whether the invoice must be in a finalized state), and no routing versus alternatives such as send_estimate or create_invoice.

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 behavioral burden. It discloses the underlying call (/me), which implies a safe, read-only, non-destructive check requiring a valid token. It does not state whether an invalid token raises an error or returns a status, nor any rate-limit or retry behavior.

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

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

A single tight sentence with the action front-loaded and the mechanism appended. Nothing wasted, nothing missing for a diagnostic check.

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 connectivity probe with no output schema and no siblings of similar kind, the description covers the essentials of what is validated. It could add one clause on expected outcome (success vs auth failure), but little else is required.

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 are no semantics to document; baseline 4 applies. The description correctly implies no input is needed beyond ambient configuration.

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 (verify) and resource (API base URL and token), and even names the endpoint used (/me). It is unambiguously distinguishable from the invoice/customer CRUD siblings, all of which operate on business data rather than connectivity.

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 is clear from the wording: run it to confirm credentials and base URL before other calls. However, it never explicitly states when to use it (e.g., before first real request, after changing config) or that it is not a substitute for a data-fetching call.

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 behavioral burden. It implies mutation but says nothing about partial-vs-full update semantics, whether unspecified fields are preserved, required permissions, or failure behavior for a nonexistent customerId.

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 efficient sentence with no waste. It is appropriately front-loaded, though the brevity contributes to its gaps elsewhere.

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 4-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin. It should at least enumerate the updatable fields and clarify partial-update behavior.

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

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

Schema coverage is 0% and the description only refers to generic 'fields' without naming the updatable properties (name, email, phone) or noting that customerId is the required identifier. It adds essentially no meaning beyond the raw 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?

States a specific verb (update) and resource (customer) and scopes it to an 'existing' customer, which implicitly distinguishes it from create_customer. However, it doesn't explicitly differentiate from siblings like update_invoice or update_estimate beyond the resource noun.

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 indication of when to use this tool versus alternatives such as create_customer or delete_customer, nor any prerequisites (e.g., that the customer must exist). Usage is only implied by the verb 'update'.

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 behavioral burden. It does not disclose whether the update is partial or full-replacement, whether omitted fields are preserved, whether changing items discards existing line items, or what permissions are required — all critical for a mutation tool with a nested array parameter.

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 single sentence is clean, front-loaded, and free of filler. However, at this level of brevity it is under-specified rather than genuinely concise given the tool's 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?

For a mutation tool with no annotations, no output schema, 7 parameters at 0% coverage, and a nested items structure, the description is far too thin. An agent would need to infer partial-update semantics, list-replacement behavior, and field formats on its own.

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% across 7 parameters, and the description adds nothing about any of them. The nested 'items' array with required name/quantity/price, the currency semantics of 'price', and the date fields are all left entirely undocumented, so the description fails to compensate for the coverage gap.

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

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

The description names a clear verb ('update') and resource ('estimate'), so an agent immediately knows this mutates an existing estimate record. It does not distinguish itself from siblings such as update_invoice or create_estimate beyond the resource name, but no such differentiation is serious for such an obvious pairing.

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

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

There is no guidance on when to use this tool versus alternatives (e.g., create_estimate for new records, convert_estimate_to_invoice for conversion), nor on prerequisites such as required permissions or estimate state. The phrase 'existing estimate' weakly implies the record must already exist.

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 behavioral burden and delivers almost none of it: it does not say whether this is a partial or full replacement, whether omitted fields are preserved, what permissions are needed, or whether the change is reversible. Only 'existing' hints at a failure mode for a missing invoice.

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?

It is a single front-loaded sentence with no filler, so it is not bloated. But at one generic clause for a 7-parameter mutation tool it is under-specified rather than genuinely concise.

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

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

A mutation tool with 7 undocumented parameters, zero annotations, and no output schema needs the description to do substantial work, and this one provides essentially nothing about behavior, required inputs, or 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?

Schema description coverage is 0% across 7 parameters, and the description supplies no parameter meaning at all — not even that items replaces or appends to line items, or that invoiceId is required. The description leaves the agent entirely dependent on field names in the schema.

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

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

The description states a specific verb and resource ('Update fields on an existing invoice'), which clearly separates it from create_invoice and delete_invoice by name. It does not, however, add anything that distinguishes it from the parallel update_estimate / update_customer siblings beyond the resource noun.

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

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

There is no guidance on when to use this tool versus create_invoice, send_invoice, or the get_* readers. 'Existing invoice' is the only implicit precondition and no exclusions or alternatives are named.

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