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

Annotations carry only a title, so the description bears the full burden of behavioral disclosure. It implies a state transition from pending to approved but says nothing about required permissions, irreversibility, downstream effects (e.g., triggering payment), or what the result looks like.

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

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

A single, front-loaded sentence with no filler. It is efficient, though its brevity contributes to the missing usage and behavioral detail rather than being purely a virtue.

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 behavioral annotations and no output schema, this description is too thin — an agent cannot tell what approval does, whether it is reversible, or what it returns. Only the parameter names are covered, via the schema.

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

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

Schema description coverage is 100%, so both parameters (expense_id, notes) are already documented in the schema. The description adds no meaning beyond identifying the target object, so the baseline of 3 applies.

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

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

The description states a specific verb (approve) and resource (expense report) and specifies the precondition that the report is pending. It does not, however, differentiate itself from the many other approval siblings such as approve_invoice, approve_time_off_request, or approve_off_cycle_payment.

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 like decline_expense or the other approve_* tools, and no mention of prerequisites such as the caller's role or the expense being in a pending state beyond the passing adjective.

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?

Only a title annotation is present, so the description carries the full behavioral burden. The word 'pending' hints at a state precondition, but nothing is said about whether approval is irreversible, whether it immediately initiates payment, what permissions are required, or what happens to an already-approved 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?

A single nine-word sentence with the action and the state constraint front-loaded. Nothing is padded and there is no redundancy.

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

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

For a state-changing approval tool with no output schema and no safety annotations, the description omits the consequences of approval, side effects on payment schedules, error behavior, and its relationship to the sibling decline/get/list invoice tools. An agent could invoke it correctly but not predict the outcome.

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

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

Schema description coverage is 100% and both parameters (invoice_id, notes) are documented in the schema, so the baseline of 3 applies. The description adds no additional meaning about the required invoice_id or the optional notes beyond what the schema already states.

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 (approve) and resource (invoice) with the state qualifier 'pending', so the agent knows it acts on an existing unapproved invoice rather than creating one. It does not explicitly distinguish itself from the sibling decline_invoice or from approve_off_cycle_payment/approve_expense, leaving that differentiation to 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?

No guidance on when to use this versus decline_invoice, approve_off_cycle_payment, or the generic payment tools. There is no mention of prerequisites such as the invoice needing to be in a reviewable state, nor any 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?

Annotations carry only a title, so the description bears the full behavioral burden. 'For processing' hints that approval triggers downstream processing and 'pending' states a precondition, but there is no disclosure of irreversibility, whether approval can be revoked, required authorization, or what happens on 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?

A single, front-loaded sentence with no filler, and the action and target come first. It is efficient, though so terse that it leaves obvious behavioral gaps unaddressed.

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, single-required-param approval action with a fully documented schema and no output schema, the description is minimally sufficient. However, with no annotations and no explanation of the state change it triggers, an agent lacks context on side effects and failure conditions.

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

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

Schema description coverage is 100%, so both parameters (payment_id and optional notes) are already documented in the schema. The description adds no syntax, format, or ID-source detail beyond that, 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 (approve) and resource (off-cycle payment), plus the precondition that the payment is pending. An agent can distinguish it from the sibling list/create/get off-cycle payment tools without reading the schema. It does not explicitly name those siblings, so it stops short of a 5.

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

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

The word 'pending' implies the payment must be in a pending state, which is a weak usage cue. There is no guidance on when to prefer this over other approval tools (approve_invoice, approve_expense), no prerequisites or permissions, and no 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?

Annotations contain only a title, so the description carries the full behavioral burden. It does not disclose whether approval is reversible, what state the request moves to, whether an approval note is surfaced to the worker, or what authorization is needed — all material for an irreversible mutation.

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 waste — the verb and resource lead. It is efficient, though the brevity comes at the cost of the behavioral detail scored 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 mutating approval tool with no annotations and no output schema, this is thin: no permission model, no post-approval state, no error conditions (e.g., request already approved or expired), and no note on the significance of the notes 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 100%, with both request_id and notes documented in the schema, so the baseline of 3 applies. The description adds nothing beyond the schema, but nothing is missing either.

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 ('Approve') and resource ('time-off request'), which cleanly separates it from list_time_off_requests and create_time_off_request. It doesn't name or contrast with the other approve_* siblings, but each targets a distinct resource, so the distinction is largely carried by the 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?

The word 'pending' implies only pending requests are approvable, but there is no explicit when-to-use guidance, no prerequisites (e.g., required permissions or approver role), and no mention of what to do instead if a request should be rejected. No alternatives are named.

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

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

The annotations only provide a title and no behavioral hints such as readOnlyHint or destructiveHint. The description implies a write/mutation operation but does not disclose permissions, side effects, required worker setup, or what happens on validation failures.

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

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

The description is a single front-loaded sentence with no wasted words. However, for an 11-parameter mutation tool, it is arguably under-sized rather than optimally sized.

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

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

Given the tool's complexity (11 parameters, mutation operation, no output schema, and only a title annotation), the description is far too sparse. It omits usage context, behavioral expectations, and any routing guidance needed to invoke it correctly.

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

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

Schema description coverage is 100%, so all 11 parameters are already documented in the input schema. The description adds no parameter-level meaning, which is acceptable at the baseline when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'Create a new contract.' It is distinguishable from list/get/update/terminate siblings by the create action, though it does not explicitly name or contrast those alternatives.

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 such as update_contract or split-contract flows, nor are prerequisites or common use cases mentioned. The description only identifies the action.

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 contain only a title, which carries no behavioral information, so the description bears the full disclosure burden. It does not state required permissions, whether names must be unique, whether parent_id must reference an existing department, or what the call returns.

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 verb and resource front-loaded and no wasted words. It is efficient, though its brevity reflects under-specification rather than optimal economy.

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 behavioral annotations and no output schema, the description omits permission requirements, failure modes, and return value. The simplicity of the tool only partially excuses these gaps.

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

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

Schema description coverage is 100%, so the schema already documents name, parent_id, and description. The description adds no semantics beyond the schema (e.g., hierarchy constraints for parent_id), so the baseline of 3 applies.

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

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

States a specific verb and resource ('Create a new department in the organization'), so the agent immediately knows the operation. It does not differentiate from siblings, though among the listed siblings there is no other department-creation tool, so the risk of confusion is low.

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 (e.g., that a department must not already exist), and does not reference the related list_departments tool. Usage context must be inferred entirely.

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

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

The only annotation is a title, so the description carries the full behavioral burden. 'Submit' faintly implies a mutation that feeds an approval flow, but it does not disclose permissions, whether the report is finalized or editable, or what happens on submission. For a 6-required-param mutation with no annotation 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, front-loaded sentence with no waste. It is efficient, though arguably under-specified rather than 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?

For a 7-parameter mutation tool with no output schema and only a title annotation, the description is inadequate: it does not explain the approval lifecycle, return behavior, or failure modes. An agent is left to guess how submission relates to approve_expense/decline_expense.

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 a documented enum for category and a URI format for receipt_url, so the schema does the heavy lifting. The description adds no additional parameter meaning beyond the schema, which is the baseline-3 case.

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 ('Submit') and resource ('expense report'), clearly a create operation that is distinct from the list_expenses/get_expense/approve_expense/decline_expense siblings. However it does not explicitly differentiate itself from those siblings by name or scope.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of the approval workflow that sibling tools imply. 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?

Annotations only carry a title, so the description bears the full behavioral burden. It does not disclose that this is a write/mutation, whether it requires approval, whether it is idempotent, or what happens on failure. For a payment-creation tool this is a meaningful 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 sentence with no waste, front-loaded with the verb and resource. It is appropriately sized, though minimally so for a 6-parameter mutation tool.

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

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

With full schema coverage the parameters are covered, and there is no output schema to explain. However, for a financial mutation tool with no annotations, the description omits essential context about approval flow, permissions, and side effects, leaving it only minimally viable.

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

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

Schema description coverage is 100%, so the schema already documents amount, reason, currency, contract_id, description, and payment_date. The description's parenthetical reason examples add nothing beyond the enum already present in the schema. 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 ('Create an off-cycle payment') and enumerates example reasons (bonus, commission, reimbursement). It is distinguishable from create_payment and approve_off_cycle_payment by name, though the description does not explicitly contrast 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 when-to-use guidance, no prerequisites (e.g. contract must exist, permission needed), and no mention of the sibling approve_off_cycle_payment that logically follows. It does not say when an off-cycle payment is appropriate versus a regular payment.

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 supply only a title ('Create Payment'), so the description carries the full behavioral burden for a mutation tool. It does not disclose permission requirements, whether it moves real money or triggers approval, whether the action is reversible, or how defaults (payment_date, payment_method_id) are resolved.

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 or redundancy; every word earns its place. It is efficient, though efficiency here comes at the cost of substance rather than being a strength of its own.

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 6-parameter mutation tool with no output schema and annotations that only name the tool, the description is far too thin. It omits usage routing, side effects, and required permissions, so an agent cannot call it correctly with confidence.

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

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

Schema description coverage is 100%, with each of the six parameters documented in the schema, so the baseline is 3. The description adds no syntax, format, or default-override detail beyond what the schema already states.

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 payment') plus a scope qualifier ('for a contract'), so the basic purpose is legible. However, it does not distinguish this tool from close siblings such as create_off_cycle_payment, leaving the agent to infer which payment type applies.

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 prerequisites, and no mention of the alternative create_off_cycle_payment. The description merely asserts that the tool creates something, leaving all routing decisions to the agent.

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 contain only a title, so the description carries the full behavioral burden. It does not disclose required permissions, whether the request enters a pending/approval state, whether it can be cancelled, or any side effects of creating the request — all material 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?

A single front-loaded sentence with no filler or redundancy. It is efficient, though the brevity borders on under-specification rather than optimal density.

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 five-parameter mutation tool with no meaningful annotations and no output schema, the description omits nearly everything an agent needs: required preconditions, the resulting request state, permission requirements, and any link to the approval flow. It is far too thin for the tool's complexity.

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

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

Schema description coverage is 100%, so each of the five parameters is already documented with its own description and format (YYYY-MM-DD dates). The description adds nothing beyond the schema, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb ('Create') and resource ('time-off request') with the target entity ('for a worker'), so the action is unambiguous. It does not, however, distinguish itself from siblings like list_time_off_requests or approve_time_off_request beyond the obvious verb difference.

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 context, no prerequisites (e.g. an existing policy_id, an active worker), and never mentions the related approve_time_off_request sibling that continues the workflow. An agent must infer everything about invocation context.

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

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

Annotations contain only a title, so the description carries the full burden of behavioral disclosure. It implies a state transition (pending to declined) but says nothing about required permissions, whether the decline is reversible, whether the reason is surfaced to the submitter, or any side effects.

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

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

A single short sentence that is front-loaded with the action and resource, with no filler. Brevity here costs some coverage, but the sentence itself 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 mutation tool with no meaningful annotations and no output schema, the description should explain permissions, side effects, and what happens to the expense afterward. None of that is present, leaving an agent unable to predict the outcome of the 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 100%: both expense_id and reason are documented in the schema, including why the reason field exists. The description adds no format, length, or validation detail beyond the schema, 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?

Clear specific verb (decline) plus resource (expense report), and 'pending' narrows the scope meaningfully. It does not explicitly name sibling alternatives like approve_expense or decline_invoice, but the action 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 word 'pending' implies the tool only applies to expenses in a pending state and therefore cannot be used on already-approved or paid items. However, there is no explicit when-to-use guidance, no mention of who may decline, and no routing toward approve_expense for the opposite decision.

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

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

The only annotation is a title, so the description carries the full behavioral burden for a mutation tool. It says nothing about whether a decline is reversible, what status the invoice moves to, whether a reason is surfaced to the counterparty, or what permissions are required.

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 with the action and its required input front-loaded and no filler. It is efficient, though arguably too terse to be maximally useful.

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-leaning mutation with no annotations and no output schema, the description should disclose reversibility, resulting state, and permission expectations. None of that is present, leaving an agent guessing about consequences.

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

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

Schema description coverage is 100% with both parameters documented, so the baseline is 3. The phrase 'with a reason' confirms the required reason parameter but adds no format, length, or content guidance beyond the schema.

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

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

States a specific verb ('Decline') and resource ('invoice') with a scope qualifier ('pending'), which cleanly separates it from approve_invoice and get_invoice in the sibling list. It stops short of explicitly naming those alternatives, so it is clear but not fully differentiated.

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?

'Pending' implies a precondition — only invoices in that state can be declined — but the description never states when to choose this over approve_invoice or what to do with a non-pending invoice. 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?

The readOnlyHint=true annotation already establishes the safety profile, so the description's job is lighter. It adds the scoping constraint that this returns an aggregate status rather than raw items, but says nothing about what the summary contains, freshness of data, or default behavior when no parameters are supplied.

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 the scope options front-loaded and no filler. It is appropriately sized, though it is thin enough that it does not demonstrate notable structural craft.

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

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

For a no-required-parameter, no-output-schema tool, the description covers the operation but omits the shape of the returned summary and the default scope when called with no arguments, which an agent would need 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 100%, so all three parameters (country, worker_id, contract_id) are already documented in the schema. The description adds no format details or precedence rules (e.g. what happens if both worker_id and contract_id are given), so it does not exceed the baseline.

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 ('compliance status summary') with clear scope alternatives ('organization or a specific worker/contract'). It is distinguishable from siblings like list_compliance_items and list_required_documents, though those distinctions are left implicit rather than named.

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 through the three scoping options (no scope = organization, worker_id, contract_id), which an agent can infer. However, there is no explicit when-to-use guidance or direction to alternatives such as list_compliance_items for itemized detail versus this summary view.

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

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

The readOnlyHint annotation already establishes this as a non-destructive read, so the description's burden is lower. It adds that the response contains 'full details' (as opposed to a list summary), but says nothing about permissions, not-found handling, or size. Adequate but thin beyond the annotation.

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 sentence of ten words with the resource and the lookup key front-loaded. No filler, nothing to trim.

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?

Simple getter with one fully documented parameter and a readOnly annotation, and no output schema exists to describe. 'Full details' gestures at the return payload, which is about as much as a one-line getter needs; only not-found/error semantics are 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?

Only one parameter and schema coverage is 100%, so the schema already documents contract_id fully. The description's 'by ID' adds nothing the schema does not, making the baseline 3 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 (Get), resource (contract), and scope (a single one, by ID, full details). This clearly separates it from list_contracts and from the mutation siblings update_contract/terminate_contract, though it never names those alternatives 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?

The phrase 'by ID' implies the precondition that the caller already knows which contract it wants, which is an implicit usage cue. However, there is no explicit guidance on when to use this versus list_contracts or get_compliance_status, and no stated error behavior for unknown IDs.

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, so safety is covered. The description confirms it's a read operation retrieving all documents. It adds nothing beyond the annotation and the name about pagination behavior or return format. With annotations covering the safety profile, a 3 is appropriate.

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. Purpose is front-loaded 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 read-only listing tool with full schema coverage and annotations, the description is adequate. However, it lacks pagination details (limit/offset behavior) and doesn't clarify how results are sorted or what fields are returned, which could matter given there's no output schema.

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

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

Schema coverage is 100%, so the schema already documents all parameters including limit, offset, and contract_id. The description adds no additional meaning about parameter usage or semantics. Baseline 3 is correct.

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?

Clear verb+resource: 'Retrieve all documents associated with a contract.' The scope is well-defined. However, it doesn't distinguish itself from the sibling list_documents or get_document, which likely serve related purposes.

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 versus list_documents or get_document. An agent has no information about when this tool is the right choice.

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

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

The annotations already declare readOnlyHint=true, so the safety profile is covered externally. The description adds one useful behavioral detail — that the response includes a download URL — but says nothing about permissions needed, URL expiry, or behavior for missing/inaccessible documents.

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; the verb, resource, and the most useful return detail are all in one compact statement.

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 one-parameter read tool whose annotations cover the safety profile, the description is nearly sufficient; naming the download URL return value compensates for the absent output schema. Only the usage routing against sibling document tools 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% for the single document_id parameter, so the schema already carries the semantics. The description adds no format, sourcing, or ID-type detail beyond it; 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 (Get) and resource (document) and adds the notable return content (download URL), which helps distinguish it from list_documents and get_contract_documents. It does not explicitly name a sibling to route between, but the purpose is unambiguous.

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

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

The description gives no guidance on when to use this versus list_documents, get_contract_documents, or get_document_template. It implies a single-document lookup via 'specific document' but states no conditions, prerequisites, or exclusions.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered by structured data. The description adds nothing beyond that restatement — no note on error behavior for an unknown ID, no auth/permission requirements, and no indication of what a template object 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 sentence with zero filler, front-loading the verb and resource. 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 low-complexity, single-parameter read tool with 100% schema coverage and readOnly annotations, the description is nearly sufficient. With no output schema, it could briefly say what a template returns, but that gap is minor at this complexity level.

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

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

Schema description coverage is 100% and the single parameter is fully documented in the schema, so the baseline is 3. 'By ID' merely echoes the schema's 'The document template ID' without adding format or sourcing guidance (e.g., where the ID comes from).

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 ('document template') plus the lookup key ('by ID'), which clearly separates it from list_document_templates. It does not name the sibling explicitly, but the singular/plural distinction makes the scope 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?

Usage is only implied: the agent can infer this is for retrieving one known template rather than enumerating them. There is no explicit when-to-use, no statement of prerequisites, and no reference to list_document_templates as the alternative for discovery.

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, so the safety profile is covered. The description adds nothing beyond that — it doesn't say what 'details' are returned, whether a not-found case is possible, or whether additional fields are populated for different entity types.

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 the verb and resource front-loaded and no wasted words. It is efficient, though the thinness reflects under-specification rather than deliberate conciseness.

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 one-parameter read operation with no output schema, the description barely suffices. Because no output schema exists, the description should ideally indicate what details are returned, which is a real gap given the many lookup-style siblings.

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

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

Schema description coverage is 100% and there is a single documented parameter (entity_id), so the schema carries the load. The description adds no meaning such as ID format, source of the ID, or accepted identifier types.

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 ('a specific legal entity'), which distinguishes it from the sibling list_entities. However, it offers no differentiation from the other get_* siblings (get_organization, get_contract, get_worker) that likely share the same retrieval pattern, so an agent must infer which resource applies.

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 contains no when-to-use guidance, no prerequisites, and no mention of alternatives such as list_entities for enumeration vs this tool for a single lookup. Usage is only implied by the word 'specific'.

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?

readOnlyHint=true already tells the agent this is a safe read, and the description is consistent with that. Beyond restating retrieval, it adds nothing about what the returned details include, whether approval/decline state is surfaced, or any access constraints, so it contributes no behavioral context of its own.

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 the key noun phrase front-loaded and zero wasted words. It is efficient, though almost too terse to be maximally informative.

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

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

No output schema exists, so the description could reasonably say more about what 'details' are returned, but the tool is simple (one required ID) and the read-only annotation covers the safety profile. Adequate but minimal for a fetch-by-ID tool.

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

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

Schema description coverage is 100% with a single, self-documented expense_id parameter, so the schema carries the semantics. The description adds no format, sourcing, or ID-provenance detail beyond what the schema provides, making baseline 3 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 ('Get details of a specific expense report'), so an agent knows it fetches a single expense record. However, it never distinguishes itself from siblings like list_expenses or get_payment, so differentiation is left to 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?

The phrase 'a specific expense report' implies retrieval by identifier, and the required expense_id parameter makes the single-record intent clear. But there is no explicit when-to-use guidance, no mention of list_expenses for browsing, and no prerequisites such as obtaining an ID 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?

The readOnlyHint annotation already establishes this as a safe read, so the bar is lower. The description adds some value by disclosing that the response includes full line item details, but says nothing about error behavior for missing IDs, permissions, or lookup semantics.

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 containing verb, resource, identifier, and return scope with zero filler.

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

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

For a simple single-record getter with only one parameter, the description is nearly sufficient; its mention of line item details partially compensates for the absent output schema. It could still say what happens when the ID is unknown, but nothing critical is missing.

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

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

With a single parameter and 100% schema description coverage, the schema already documents invoice_id. The description adds no format, source, or validity information beyond what the schema provides, so baseline 3 applies.

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

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

The description states a specific verb (Get) and resource (a specific invoice) plus a scope qualifier (by ID, with full line item details). This implicitly separates it from the sibling list_invoices, but it never names an alternative or 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: nothing tells the agent to use this over list_invoices or get_payment, nor that a valid invoice_id is required. The 'by ID' phrasing implies single-record retrieval, but no condition or prerequisite is 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?

The readOnlyHint annotation already declares this is a safe, non-mutating operation, and the description is consistent with that. The description adds no behavioral context beyond the annotation — no note on failure when the ID does not exist or on what "details" comprises — but for a simple read tool there is little behavior left to disclose.

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 eleven-word sentence with the verb and resource front-loaded and 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 one-parameter read tool this is close to sufficient, but with no output schema the description never indicates what "details" are returned, so an agent cannot anticipate the response shape. Low complexity offsets much of that 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?

There is a single parameter with 100% schema description coverage, so the schema already explains payment_id fully. The description adds no extra meaning (e.g., where to obtain the ID), which is acceptable at the baseline when the schema carries the load.

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 pairs a clear verb ("Get") with a specific scoped resource ("off-cycle payment") and signals single-record retrieval via "a specific." It is unambiguous on its own, but it never differentiates itself from adjacent siblings such as list_off_cycle_payments or the generic get_payment, so the agent must infer the routing.

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?

"a specific off-cycle payment" implies you must already have an identifier and that this is a single-record lookup rather than a listing, which is implicit guidance. There is no explicit statement of when to use this versus list_off_cycle_payments or get_payment, and no prerequisites are named.

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

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

The readOnlyHint annotation already establishes this as a safe read operation, and the description adds no behavioral context beyond that. It does not disclose return format, whether settings are cached or live, or any auth/permission requirements, so it is largely redundant with the annotation.

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 no-parameter 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 zero-parameter read-only tool with annotation coverage and no output schema, the description is sufficient to invoke correctly. It could be slightly more complete by hinting at what 'settings' includes, but nothing critical is missing.

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

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

The schema has zero parameters, which sets the baseline at 4 per the rubric. The description correctly implies no parameterization by scoping to the 'current organization', and there are no parameters requiring further explanation.

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 ('the current organization's profile and settings'), so the agent knows exactly what it retrieves. It does not explicitly distinguish itself from sibling getters like get_entity or get_worker, but the singleton 'current organization' scope is clear.

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 guidance, no mention of prerequisites, and no alternatives named among the many sibling tools. The only implied guidance is that no identifier is needed because it targets the current organization.

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, so the safety profile is covered by structured data. The description adds nothing beyond that — no statement of behavior when the ID is unknown (error vs empty), no permission requirements, and no indication of what 'details' comprises.

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 the resource and lookup key front-loaded and zero filler. It is appropriately sized, though it is arguably under-specified rather than truly 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?

For a read-only get-by-ID tool with annotations covering safety and no output schema, the description is minimally sufficient to invoke it correctly. It still leaves the return contents and not-found behavior unspecified, which matters given the absence of an output schema.

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

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

Only one parameter exists and the schema documents it at 100% coverage ('The payment ID'), so the baseline is 3. The phrase 'by ID' in the description adds no format, prefix, or lookup semantics beyond what the schema already states.

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 ('details of a specific payment') with the retrieval key ('by ID'), which is clearer than a bare name restatement. However, it does nothing to distinguish itself from the close siblings get_payment_status, list_payments, and get_off_cycle_payment, so an agent must infer the boundary on its own.

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 prerequisites, and no mention of the alternative tools that overlap with it (get_payment_status for status, list_payments for enumeration). Usage is only implied by the word 'specific ... by ID'.

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

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

The annotation readOnlyHint=true already establishes that this is a safe, non-mutating read, so the description adds no safety context. Beyond that it says nothing about what statuses can be returned, whether the value is eventually consistent or cached, or any rate limits, leaving the behavioral profile bare.

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 front-loaded sentence with no filler or redundancy. It is efficient, though bordering on under-specification for the operation it describes.

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 one-parameter read tool with no output schema, the description should at least characterize the return (e.g., the set of status values) and its relation to get_payment. It is minimally viable but leaves a meaningful gap given there is no output schema to fall back on.

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% for the single payment_id parameter, so the schema already documents the input. The description adds no format, prefix, or source hints beyond what the schema provides, which is the baseline-3 case for fully covered params.

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 verb (Check) and resource (payment) with a stated scope (current status), so the operation is unambiguous. However, it gives no indication of how it differs from the sibling get_payment, which plausibly returns overlapping data, so the agent cannot distinguish them from the text 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?

There is no guidance on when to use this tool instead of get_payment, list_payments, or get_off_cycle_payment, nor any stated prerequisites (e.g., whether the payment must be settled first). Usage must be inferred 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?

Annotations already declare readOnlyHint=true, so the non-mutating nature is covered structurally; the description's phrase 'detailed information' adds a mild signal that this returns a full record rather than a summary. It says nothing further about what 'detailed' includes, whether the record can be missing, or any error behavior, so it is only marginally additive.

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, efficiently worded sentence with the resource and scope front-loaded. It is appropriately sized for a one-parameter read, though 'detailed' is slightly vague filler.

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

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

For a simple one-param read with no output schema, the description is barely sufficient. It does not hint at what fields the worker record contains or how the ID is obtained (likely from list_workers/search_workers), which is the main missing context for invoking it correctly.

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

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

With a single parameter at 100% schema description coverage, the schema already documents worker_id = 'The worker ID'. The description adds no format hints (e.g., ID source or lookup semantics), so the baseline of 3 applies.

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

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

States a specific verb (get) and resource (worker) with a scoping qualifier ('a specific worker'), so the agent understands it retrieves a single worker rather than a list. However, it does nothing to differentiate from siblings like list_workers, search_workers, or get_entity, leaving the agent to 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?

No when-to-use guidance and no mention of alternatives. The agent must guess that search_workers/list_workers are the lookup paths and that this tool is the follow-up detail fetch by known ID. No prerequisites or exclusions 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?

Annotations carry only a title, so the description bears the full disclosure burden. 'Invite' implies an email is sent and a pending worker record is created, but the description never states side effects, required permissions, whether the invite is reversible, or what state the worker lands in.

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 waste. It is efficient, though the extreme terseness borders on 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?

For a mutation tool with seven parameters, no annotations beyond a title, and no output schema, the description is far too thin. It omits side effects (invitation email, created record), permission requirements, and the resulting worker status that an agent needs before invoking it.

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

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

Schema description coverage is 100%, so all seven parameters (including country as ISO 2 and optional contract_id/department_id) are already documented in the schema. The description adds no format, constraint, or linkage detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Invite a new worker') and names the platform (Deel), so the agent knows exactly what operation this is. It does not, however, differentiate itself from nearby siblings such as update_worker, offboard_worker, or create_contract, which all touch the worker lifecycle.

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 prerequisites, and no mention of alternatives. The agent cannot tell from the description whether this is the correct tool for onboarding vs. creating a contract, nor what condition should select it over list_workers or create_contract.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds organization-level scoping and says results include status, but does not describe pagination behavior, filter interactions, or whether it returns all items or a paginated subset.

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

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

The description is a single front-loaded sentence with no wasted words. It immediately states the operation and resource.

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

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

For a read-only list tool whose annotations and schema cover safety and parameters, the description is minimally viable. It does not clarify the relationship to nearby compliance tools or reconcile the word 'all' with the seven available filter and pagination parameters.

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

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

Schema description coverage is 100%, so all seven parameters are already documented in the schema. The description adds no additional parameter meaning, making the baseline of 3 appropriate.

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

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

The description states a clear verb and resource ('List all compliance items and their status'), so an agent knows the general operation. However, it does not distinguish this tool from sibling compliance tools such as get_compliance_status or list_required_documents, leaving the agent to infer the boundary.

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 guidance or comparison to alternatives. The phrase 'for the organization' implies scope but does not tell the agent when this list tool is preferable to get_compliance_status or list_required_documents.

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?

readOnlyHint=true already establishes this is a safe read, so the bar is lower. The description adds organizational scope but says nothing about pagination behavior; 'List all' is mildly in tension with the schema's default limit of 20, though not a true contradiction.

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

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

Two short sentences, front-loaded with the core purpose before the filtering capability. No filler or redundancy, though the filtering clause is a partial list that stops short of full coverage.

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, fully documented read-only list tool this is minimally adequate, but with no output schema it says nothing about the shape of returned contract records or pagination semantics, which an agent calling a paginated list endpoint would benefit from knowing.

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 documented enums for type and status, so the schema carries parameter meaning. The description only echoes three of the six filters and omits country, worker_id, limit, and offset, adding no new semantic 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 and resource ('List all contracts') and scopes it to 'your Deel organization'. It does not explicitly differentiate itself from siblings like get_contract or list_workers, but the enumeration/collection intent is unambiguous.

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

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

The description implies usage (browse/filter the contract collection) and names filterable attributes, but gives no explicit when-to-use guidance, no mention of when to prefer get_contract for a single record, and no prerequisites.

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, so the safety profile is covered. The description adds only the org-wide scope ('in the organization') and does not mention default page size, pagination behavior, or that parent_id can narrow results. With annotations doing the heavy lifting, this is minimally adequate rather than rich.

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

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

A single short sentence, front-loaded with the action and resource, with no wasted words. It is efficient but does not use the available space to convey any additional useful context.

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

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

No output schema exists, so return values need not be explained, and all three parameters are documented in the schema. However, for a paginated list endpoint the description omits any indication of pagination or filtering behavior, leaving the agent to discover it from the schema alone.

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

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

Schema description coverage is 100%, so limit, offset, and parent_id are already documented in the schema. The description adds nothing about parameter usage and even implies no filtering with 'all departments', 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 clear verb and resource (list departments) and scopes it to the organization. It doesn't differentiate from siblings explicitly, though the read-only list vs. create_department distinction is obvious from the name. The word 'all' is slightly at odds with the pagination and filter parameters but still conveys the intent.

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 versus alternatives, no mention of prerequisites or permissions, and no hint that results are paginated or filterable. The agent must infer usage purely 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?

Annotations already declare readOnlyHint=true, so safety is covered. Beyond that the description only restates org-wide scope; it says nothing about pagination behavior, result ordering, or whether it is unbounded, leaving whatever the agent needs about the response to 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 filler; the resource and scope come first. Its brevity borders on under-specification rather than waste, but nothing in the sentence is redundant.

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

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

For a read-only, zero-required-parameter list tool with a fully documented schema and no output schema, this is minimally adequate. It still lacks sibling routing guidance and any note on paginated/aggregate results, which matters in a namespace crowded with other document-listing tools.

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 six parameters documented (type, status enum, worker_id, contract_id, limit, offset), so the schema carries the semantics. The description's generic 'optional filters' adds no syntax, allowed values, or defaults beyond that, making the baseline 3 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 (List) and resource (documents) with an explicit org-wide scope, so the agent knows what it returns without opening the schema. However, it offers no differentiation from closely related siblings like get_contract_documents, list_required_documents, or list_document_templates.

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?

'with optional filters' hints that filtered listing is supported, but there is no statement of when to choose this tool over get_document, get_contract_documents, or list_required_documents, and no exclusions or prerequisites 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?

Annotations already declare readOnlyHint=true, so the safe-read profile is covered. The description adds only that templates are used for creating contracts and agreements; it says nothing about result set size, pagination continuation, or whether the list is exhaustive versus filtered.

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 verb and resource lead immediately. Nothing to trim.

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 four-parameter read-only listing with no output schema, the description omits pagination behavior and available filter dimensions, which the schema documents but the agent-facing summary does not reinforce. It is minimally adequate rather than complete.

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

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

Schema description coverage is 100%: type, limit, offset, and country are each documented in the schema, including defaults and bounds. The description adds no filtering or pagination semantics beyond that, 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?

Clear verb (List) plus specific resource (document templates) and a scoping note that these are for creating contracts and agreements. It does not explicitly differentiate from the sibling get_document_template or list_documents, so an agent must infer the plural-listing vs. single-get 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?

Usage is implied by 'List available' and the contract/agreement context, but there is no explicit when-to-use guidance, no mention of when to prefer get_document_template for a single template, and no prerequisites or pagination guidance.

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

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

The readOnlyHint annotation already establishes this as a safe non-mutating read, so the bar is lower. The description adds that results are org-scoped, which is useful context, but says nothing about pagination behavior or result ordering even though limit/offset exist.

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

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

A single nine-word sentence with zero filler, front-loading the verb and resource. Nothing to trim.

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

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

For a simple read-only list tool with a fully documented schema and no output schema, the description is minimally adequate but does not mention the country filter or that results are paginated. It covers the essentials without being complete.

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

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

Schema description coverage is 100%, so limit, offset, and country are all documented in the schema itself. The description adds no syntax or format detail beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('List legal entities') plus a scope ('belonging to the organization'), which separates it from the singular sibling get_entity. However it never names get_entity or any other alternative, so sibling differentiation is left to 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?

No when-to-use context, no prerequisite, and no pointer to the singular get_entity for retrieving one entity. The agent must infer usage from the name alone.

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

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

The readOnlyHint=true annotation already tells the agent this is a safe read, so the description carries a lighter burden — but it adds nothing beyond that. It does not mention pagination behavior, default page size, or result ordering, all of which matter for a 7-parameter list 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 with no filler, so nothing is wasted. It is arguably too terse rather than verbose, which is a completeness problem rather than a conciseness one.

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 7 parameters and no output schema, the description should at least indicate what the list returns and how pagination behaves, since there is no structured output to fall back on. As written, an agent cannot tell the response shape or default paging from the definition alone.

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

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

Schema description coverage is 100%, so the schema fully documents the limit, offset, status enum, dates, category, and contract_id. The description's 'optional filters' adds no meaning beyond the schema, and per the high-coverage baseline a 3 is appropriate.

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

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

The description states a specific verb and resource ('List expense reports'), which is clear enough to distinguish it from get_expense or create_expense by intent. However, it offers no differentiation from other list_* siblings in this dense tool set, so it stops short of a 5.

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

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

'with optional filters' hints at when filtering applies but gives no guidance on when to choose this tool over get_expense (single record) or the approve/decline variants. No prerequisites, exclusions, or alternative routing 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?

The readOnlyHint annotation already establishes this is a safe read. The description adds no behavioral context beyond that: no mention of pagination behavior, result ordering, or what 'adjustments' contain structurally.

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 the key scope front-loaded. It is appropriately sized for a simple list operation, though it offers no extra structural guidance.

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

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

For a simple read-only list tool with full schema coverage and no output schema, the description is minimally adequate. It does not mention pagination behavior or the paginated nature of the response, which would help an agent using limit/offset.

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

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

Schema description coverage is 100%, so all three parameters (invoice_id, limit, offset) are documented in the schema itself. The description adds no format or syntax detail beyond what the schema already provides, which is the baseline expectation.

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

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

States a specific verb (List) and resource (adjustments for an invoice), and clarifies the resource with examples (bonuses, deductions). It is clearly distinct from siblings like list_invoices or get_invoice. However, it does not explicitly contrast itself with those siblings.

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

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

No when-to-use guidance, no prerequisites, and no alternatives named. An agent must infer that this is the tool for retrieving adjustments once an invoice_id is known.

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

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

The annotations already declare readOnlyHint=true, so the safety profile is covered. Beyond that the description adds no behavioral context — no pagination semantics (limit/offset behavior or defaults), no indication of result volume, ordering, or what an empty result looks like. For a list tool with no output schema this is a notable 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 compact sentence with the resource named first and the filter capability trailing, so the important information is front-loaded. There is no filler, though the sentence carries essentially no information beyond the tool name and schema.

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 six optional parameters, no required arguments, and no output schema, the description leaves the agent to infer pagination behavior and return shape entirely from the schema. It is complete enough to invoke, but not complete enough to predict what comes back or how to page through 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 100%, so status, contract_id, from_date, to_date, limit, and offset are all already documented in the schema. The description restates three of those filter dimensions but adds no format, default, or enumeration detail beyond what the schema provides, so the baseline of 3 applies.

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

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

The description states a specific verb (List) and resource (invoices) and enumerates the filter dimensions, so the agent immediately knows it returns a collection rather than a single record. It does not explicitly contrast itself with siblings like get_invoice or the other list_* tools, so it stops short of full differentiation.

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: 'optional filters' signals that filters can be omitted to list everything, but there is no explicit statement of when to use this tool versus get_invoice, list_invoice_adjustments, or list_payments. No prerequisites, 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.

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

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful examples of off-cycle payment types, but it does not disclose pagination behavior, ordering, or what the returned records contain.

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

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

The description is a single front-loaded sentence with no wasted words, and the core action and resource come first.

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 six-parameter, read-only list tool with fully described parameters and no output schema, the description covers the basic purpose but omits return-shape context and guidance on when to choose this tool over related siblings.

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

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

Schema description coverage is 100%, so all six parameters are already documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, which is the expected baseline when the schema does the heavy lifting.

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

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

The description states a specific verb (List) and resource (off-cycle payments), with examples that clarify what counts as off-cycle. It does not, however, explicitly distinguish this from the sibling list_payments tool, so the sibling boundary is left implicit.

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 context is 'with optional filters,' which does not explain when to use this tool versus list_payments, get_off_cycle_payment, or other payment-related siblings. No exclusions or prerequisites are provided.

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

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

Annotations already declare readOnlyHint=true and supply the title, so the safety profile is covered. The description adds the organization-level scope (no per-user filtering), which is meaningful, but says nothing about result ordering, pagination behavior, 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 zero filler. It is efficient, though the brevity borders on under-specification rather than crispness.

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 paginated read this is adequate, and annotations cover the read-only nature. But with no output schema, the description could reasonably say what a "payment method" object contains or whether the list is paginated, and it leaves that entirely 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 description coverage is 100% and both parameters (limit, offset) are fully documented in the schema with defaults and bounds. The description adds no format or semantics beyond that, 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 ("List") and resource ("payment methods") and scopes it to "the organization." However, it does nothing to distinguish itself from the many other list_* siblings (list_payments, list_invoices, list_contracts) or to clarify how payment methods differ from payment records.

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 exclusions, and no named alternative. The agent must infer from the name alone that this retrieves stored payment methods rather than payment transactions.

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

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

Annotations already declare readOnlyHint=true, and the description adds essentially nothing beyond that safety profile plus the filter names, which the schema already documents. No mention of ordering, default result behavior, or pagination semantics beyond what the schema states.

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 resource and filter scope front-loaded and no filler. It is appropriately short for a simple list operation, though it is thin enough to leave gaps the evaluator must note 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 six-parameter, all-optional list tool with no output schema, the description covers the operation but says nothing about result shape, ordering, or how pagination interacts with filters. Adequate but with clear gaps given the absent output schema.

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

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

Schema description coverage is 100%, so all six parameters (limit, offset, status enum, date range, contract_id) are already documented in structured form. The description only echoes the filter categories, adding no new semantic detail, 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 precise verb+resource ('List all payments') and names the filter dimensions, so an agent knows what it returns. It does not distinguish itself from near-siblings like list_off_cycle_payments or get_payment, which is the only thing keeping it from a 5.

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

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

No guidance on when to use this versus list_off_cycle_payments, get_payment, or get_payment_status. The listing intent is implied by the verb, but no alternatives or exclusion conditions are provided.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered by structured data. The description adds only the scope dimensions, not pagination behavior, default ordering, or what 'required' means (derived vs configured). It adds some value but no notable behavioral context.

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

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

A single front-loaded sentence with no filler; the resource and the scoping options come first.

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

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

For a read-only filtered list tool with fully documented parameters and no output schema, the description covers what is needed to call it. It could note filter combination behavior, but 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%, so all six parameters (limit, offset, country, worker_id, contract_id, is_submitted) are documented in the schema itself. The description merely restates three of the filter axes without adding semantics such as precedence when multiple filters are supplied.

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 a specific resource ('required compliance documents') and enumerates the three scoping dimensions. It does not distinguish itself from near-siblings such as list_documents or list_document_templates, but an agent can tell what this tool returns.

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 scope phrase ('for a worker, contract, or country') implies when the tool is applicable, but there is no explicit when-to-use guidance and no mention of alternatives like list_documents. 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, so safety is covered by structured data rather than the description. The description adds only the organizational scoping phrase ('configured in the organization') and says nothing about pagination behavior, default page size, or whether the result set is filterable.

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 or redundancy. It is efficient, though brevity here edges toward under-specification rather than true conciseness.

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 four-parameter, filterable list tool with no output schema, the description covers the core purpose but omits any note on pagination defaults, filterable dimensions, or the distinction from time-off request listing. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so all four parameters (type, limit, offset, country) are already documented in the schema. The description adds no filtering syntax or format guidance beyond that, 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 (list) and resource (time-off policies) with an organizational scope. It is distinguishable from list_time_off_requests in principle, but the description never explicitly contrasts the two, so an agent must infer that 'policies' are configuration objects rather than employee requests.

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. The listing intent is implied by 'List all', but nothing tells the agent when this tool is the right choice over list_time_off_requests or the department/contract listers.

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, so the safety profile is covered. The description adds nothing beyond that: it does not mention pagination (limit/offset exist in the schema), result caps, sort order, or what the response contains, so it contributes no behavioral context the structured fields don't already carry.

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

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

A single front-loaded sentence with the resource statement ahead of the filter qualifiers and no filler. It is efficient, though the terseness is part of why other dimensions are thin.

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

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

For a simple read-only list endpoint with a fully documented schema and no output schema, the description is minimally adequate. It omits pagination behavior, which is the one meaningful gap an agent would want for a list tool, but nothing an agent needs to invoke it correctly is strictly 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% and all six parameters are documented in the schema, including enum values for status. The description's mention of worker/status/date filters merely mirrors the schema and adds no format or syntax detail, 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 gives a specific verb+resource ('List time-off requests') and names the filter dimensions. It is immediately distinguishable from write siblings like create_time_off_request or approve_time_off_request, but it never explicitly names an alternative or contrasting scope the way a 5 would.

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 versus list_time_off_policies or the approve/create time-off siblings, and no exclusions or prerequisites. Usage is only weakly implied by the list semantics; the agent gets no routing help.

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, so safety is covered. The description adds nothing beyond that: no pagination behavior, no note on default/maximum page size, no indication of result ordering or volume limits for an organization-wide list.

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 zero filler. It is efficient, though its brevity comes at the cost of the routing and pagination context an agent would want.

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 five-parameter, filterable list endpoint with no output schema and several overlapping siblings, the description omits how results are paged, how this differs from search_workers, and whether filtering changes the 'all workers' claim. It is too thin for the tool's complexity.

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

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

Schema description coverage is 100%, so all five parameters (limit, offset, status, country, department) are fully documented in the schema. The description contributes no additional parameter meaning and its 'all workers' phrasing slightly obscures the availability of filters, 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 (list workers) and scopes it to the caller's Deel organization. However, it does not differentiate itself from sibling tools like search_workers or get_worker, and the word 'all' is in mild tension with the filter parameters the schema exposes.

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 search_workers (filtered lookup) or get_worker (single record). No prerequisites or exclusions are stated, leaving the agent to infer routing from the name alone.

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?

Only a title annotation is present, so the description carries the full behavioral burden for what is clearly a consequential mutation. It says nothing about what 'the offboarding process' actually does (access revocation, final payment, termination of record), whether it is reversible, or what permissions are required. The word 'initiate' hints at a multi-step process but the side effects remain undisclosed.

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

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

A single front-loaded sentence with no redundant or filler text. It is efficient, though its brevity borders on under-specification for the complexity of the operation (captured under contextual completeness).

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

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

For a high-impact worker offboarding mutation with 5 parameters, no annotations, and no output schema, a single sentence is insufficient. An agent gets no information on side effects, reversibility, permissions, or expected outcomes, leaving it unable to judge invocation risk.

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

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

Schema description coverage is 100% and each of the 5 parameters is documented in the schema (worker_id, last_day, reason, notes, rehire_eligible). The description adds no additional parameter meaning, but with full schema coverage the baseline of 3 is appropriate.

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

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

States a specific verb ('offboarding') and resource ('a worker'), so the agent knows this is a worker lifecycle operation distinct from terminate_contract or update_worker. It is clear but does not explicitly differentiate itself from sibling worker tools, so it does not reach a 5.

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

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

The description gives no when-to-use guidance, no prerequisites (e.g., worker must be active), and no alternatives or exclusions relative to siblings like update_worker or terminate_contract. The agent is left to 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?

The readOnlyHint annotation already establishes this is a safe read operation, and the description adds essentially nothing beyond that — no note on match semantics (partial/prefix vs exact despite the schema), no pagination behavior, no result ordering. With annotations covering the safety profile, the description still leaves the read behavior under-described.

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, tightly scoped sentence with no filler and the key concept (worker search) front-loaded. It is efficient, though perhaps too terse to carry much value.

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

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

For a simple 3-parameter read tool with full schema coverage and a readOnlyHint annotation, this is minimally adequate. The lack of sibling disambiguation and matching semantics leaves a small but real gap given there are several other worker tools.

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 query, limit, and offset all documented inline, so the schema does the heavy lifting. The description's 'name or email' phrasing merely restates the query parameter's schema description and adds no format or matching 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 ('Search') and resource ('workers') plus the matching fields (name, email), which is enough to know what the tool does. It does not differentiate itself from close siblings like list_workers, get_worker, or invite_worker, so an agent must infer the boundary between searching and listing.

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 list_workers (browse-all) or get_worker (single lookup by id), and no prerequisites or exclusions given. The matching-by-name-or-email hint implies usage but does not state it as a selection rule.

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 only provide a title, so the description carries the full behavioral burden. It mentions the authenticated user as signer but does not disclose whether signing is irreversible, what permissions are required, what happens if the document is already signed, or what the result contains.

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

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

The description is a single front-loaded sentence with no filler. It is appropriately sized for a simple two-parameter mutation tool.

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

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

For a mutation tool with no meaningful annotations and no output schema, the description is too thin. It does not describe side effects, permissions, error cases, or return behavior, leaving key operational context absent.

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

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

Schema description coverage is 100%, so the schema already documents document_id and signature. The description adds no parameter-level detail beyond what the schema provides, making the baseline of 3 appropriate.

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

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

The description states a specific verb (sign) and resource (pending document) and adds the actor context ('on behalf of the authenticated user'). It is clear what the tool does, though it does not explicitly differentiate from sibling document tools beyond the 'pending' qualifier.

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 only for pending documents but provides no explicit when-to-use guidance, no prerequisites, and no alternative tools to consider. An agent must infer whether to fetch or verify a document before signing.

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 carry only a title, so the description bears the full behavioral burden for a clearly destructive operation. It does not say whether termination is reversible, what permissions are required, or what happens to severance/last-day-of-work fields.

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

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

A single front-loaded sentence with zero filler. It is efficient, though the brevity reflects under-specification as much as conciseness.

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, irreversible-sounding mutation with no annotations and no output schema needs the description to explain side effects, permissions, and irreversibility. None of that is present, so the definition is incomplete for the tool's complexity.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds no format, default, or conditional detail beyond that, 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 (terminate) and resource (contract), scoped to 'active' contracts. It is clear what the tool does, but it does not distinguish itself from sibling mutators like update_contract or offboard_worker.

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 versus update_contract or offboard_worker, nor any prerequisites (e.g., contract must be active, approvals needed). The 'active' qualifier hints at a precondition but never states one.

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 provide only a title, so the description carries the full burden for a mutation tool. It does not disclose whether this is a partial update (omitted fields unchanged) or a replace, what permissions are required, or whether changes are reversible.

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 and free of waste. It is efficient, though its brevity is partly a symptom of under-specification rather than disciplined compression.

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 six-parameter mutation tool with no annotations and no output schema, the description is too thin. It omits partial-update semantics, permission requirements, and error behavior, so an agent lacks enough context 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 coverage is 100%, so every parameter including contract_id and the updatable fields is already documented in the schema. The description adds no syntax, format, or behavioral detail beyond what the schema provides, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb (update) and resource (contract), making the operation unambiguous. However, it offers no differentiation from siblings like get_contract, create_contract, or terminate_contract, which an agent must distinguish between.

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_contract, terminate_contract, or get_contract. No prerequisites or conditions are stated, leaving the agent to infer usage entirely.

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

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

The only annotation is a title, so the description carries the full behavioral burden. It does not say whether the update is partial or full-replacement, whether omitted fields are cleared or preserved, what permissions are required, or whether changes are reversible.

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. It is efficient, though its brevity is partly under-specification rather than optimal density.

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 7-parameter mutation tool with no annotations beyond a title and no output schema, one sentence is not enough. An agent cannot determine update semantics (partial vs. full), permission requirements, or what the call returns.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters (names, job_title, manager_id, etc.). The phrase 'profile information' loosely frames the updatable fields but adds no syntax, format, or constraint detail beyond what the schema provides; 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 states a specific verb ('Update') and resource ('an existing worker's profile information'), so an agent can immediately tell this mutates a worker record rather than reading, listing, or offboarding one. It does not, however, explicitly differentiate itself from siblings like invite_worker or offboard_worker.

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 choose this tool over alternatives such as invite_worker (new hire), offboard_worker (termination), or get_worker (read). No prerequisites or preconditions are stated.

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