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

With no annotations provided, the description carries the full behavioral burden. It does valuable work by tagging this as a WRITE operation and disclosing reversibility, but it doesn't explain what archiving actually does downstream (e.g., whether the account disappears from list_bank_accounts, how restoration works, or any 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?

Two compact sentences, with the WRITE marker and the core function front-loaded, followed immediately by the disambiguation. Every clause carries signal; nothing 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 mutation tool with no annotations and no output schema, the description covers the essentials (what it does, that it's reversible, which sibling it replaces) but leaves behavioral gaps: state after archiving, restoration path, and error/permission conditions are unaddressed.

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, accountId, fully documented in the schema at 100% coverage, so the schema already does the work. The description adds no format, ID-source, or constraint detail beyond what the schema supplies, which is the baseline 3 for high schema coverage.

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 ('archives') and resource ('treasury bank account in Holded, API v2'), and explicitly contrasts it with the sibling delete_bank_account. An agent can distinguish this from the delete/create/update bank account siblings without inspecting schemas.

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

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

It explicitly routes the agent: use this as the 'reversible alternative to delete_bank_account,' which is a clear when-to-use signal against the most likely competing tool. It stops short of stating prerequisites (permissions, whether archived accounts remain visible or can be unarchived), so no full 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses the multipart POST mechanics and the docType support restriction, which is useful, but omits permissions/auth requirements, file size limits, and what happens on failure or what the response contains.

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

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

Front-loaded with the purpose, then endpoint mechanics and the docType caveat. Dense and mostly earns its place, though the raw endpoint path is implementation detail an agent may not need.

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 4-param mutation tool with no annotations and no output schema. The description covers purpose, endpoint, and the docType restriction, but leaves notable gaps around auth, size limits, and response/failure behavior.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds genuinely useful meaning beyond the enum: purchaserefund is in the schema enum but not actually supported, which prevents a likely incorrect invocation.

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 (attach a file to a document) and specifies the API version. It's clearly distinguishable from read-only siblings like list_contact_attachments, though it doesn't name any sibling 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?

Provides one explicit when-not condition ('supported for all docTypes except purchaserefund'), which is valuable. But there's no general guidance on when to use this vs. other document tools or prerequisites (e.g., that the document must exist).

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

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

With no annotations, the description carries the full burden, and it does usefully flag WRITE and "Affects real working-time records," making the side effect clear. However, it omits behavior an agent needs: what happens on duplicate clock-ins, whether the operation is idempotent, required permissions, and what an error 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?

Two short fragments with zero waste, and the WRITE marker is front-loaded so the mutation nature is immediately visible. It leans slightly toward under-specification rather than verbosity.

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

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

For a one-parameter mutation tool with no annotations and no output schema, the description covers purpose and side effect but not result shape, duplicate-handling, or permissions. Adequate as a minimum, but there are clear gaps for a write operation.

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

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

There is only one parameter (employeeId) and schema description coverage is 100%, so the baseline is 3. The description adds no meaning beyond the schema — it doesn't say where the employee ID comes from or what happens if it's invalid.

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 ("registers a clock-in for an employee") and names the system (Holded time tracking, API v2). It implicitly distinguishes itself from clock_out_employee and pause_employee via the direction of the action, though it doesn't name those siblings 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?

There is no guidance on when to use this versus clock_out_employee, create_employee_time, or pause_employee, and no exclusions or preconditions. The closest thing is the warning "Affects real working-time records," which is a side-effect note rather than routing guidance.

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

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

No annotations are provided, so the description carries the full burden. The explicit 'WRITE:' prefix usefully signals a mutation and naming API v2 adds a little context, but it omits whether the clock-out timestamp is auto-generated, whether it fails when no open clock-in exists, and whether it is idempotent.

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 tight sentence with the mutation type front-loaded as 'WRITE:' and no filler. Every clause carries information about the action, target, and system.

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

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

For a single-parameter, no-output-schema tool this covers the essentials of what it does, but with no annotations the description should also say what happens on a failed clock-out or how the timestamp is determined. It is adequate but leaves real behavioral questions open.

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

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

Schema coverage is 100% for the single employeeId parameter, so the schema already documents it. The description adds no meaning about the parameter, which is the baseline-3 case when the schema does the work.

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 ('registers a clock-out') and resource ('an employee in Holded time tracking'), which is clearly distinguishable from siblings such as clock_in_employee or pause_employee. It stops short of explicitly naming those siblings as alternatives, so it lands just below the top band.

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

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

There is no guidance on when to use this versus clock_in_employee, pause_employee, unpause_employee, or create_employee_time. Nothing states preconditions such as an employee having an open clock-in, so the agent must infer all conditions for use.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the key trait that this is a write and that `data` is sent verbatim as the raw request body, which tells the agent it must assemble a complete payload itself. However, it says nothing about required permissions, duplicate-name handling, or what a successful 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?

Two sentences, front-loaded with the 'WRITE:' mutation marker, with no filler. The only structural weakness is outsourcing the substantive payload detail to an off-tool documentation link.

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

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

This is a mutation tool with no annotations, no output schema, and a nested `data` object whose fields are undefined in the schema. The description's answer to that gap is a URL, which an agent may not be able to fetch, leaving it unable to construct a valid payload 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?

Only one parameter exists and schema coverage is nominally 100%, so the baseline is 3. The description adds the meaningful detail that the object is passed through verbatim with no transformation, but the nested payload's actual fields are documented nowhere in the schema and are deferred entirely to an external URL.

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: creates an accounting account in the Holded chart of accounts, plus the API version. It is clear what it does, but it never distinguishes itself from nearby siblings such as create_expenses_account, create_ledger_entry, or the read-side list_accounting_accounts / get_chart_of_accounts.

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

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

There is no when-to-use or when-not-to-use guidance, no prerequisites, and no mention of alternatives. The 'WRITE:' prefix implies mutation, but an agent choosing among several create_* accounting-adjacent siblings 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?

With no annotations, the description carries the burden; it does disclose that this persists a real account ('real', 'WRITE') and that the body is passed verbatim without validation or transformation. It omits permissions/auth requirements, what the response contains (e.g., created ID), and error behavior, which matter for a mutation 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?

Two short sentences, front-loaded with the WRITE marker, with a documentation pointer instead of bloated prose. Slight redundancy between the description and the schema's 'sent verbatim as body' wording keeps it from a 5.

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

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

For a mutation tool with no annotations, no output schema, and an unconstrained nested payload, the external reference link is the right compensation for field-level detail. Still missing is any statement of what a successful call returns or what failure looks like, which leaves the agent guessing about verification after 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 coverage is 100% and the nested `data` object is intentionally opaque, so baseline is a 3. The description reinforces 'sent verbatim as the request body' but largely repeats the schema text; the added value is the external API reference where the payload shape is actually documented.

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 ('creates a real treasury bank account in Holded') and flags the write nature up front. It does not, however, differentiate itself from the sibling create_treasury, which an agent could reasonably confuse with it.

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 statement of when to use this tool versus create_treasury, update_bank_account, or the other creation tools in the family, and no prerequisite or verification guidance. The 'WRITE:' prefix signals impact but not routing.

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

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

With no annotations provided, the description carries the full behavioral burden. It usefully discloses that this creates a real bank movement and that data is sent verbatim, but it does not explain permissions, idempotency, side effects, validation behavior, or what happens on failure, which are important for an unannotated write operation.

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

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

The description is two compact sentences with the mutating nature and resource front-loaded. Every element, including the documentation link, serves a clear purpose without repetition.

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 write tool with a required nested data object, no output schema, and no annotations, the description delegates the payload structure entirely to an external URL. An agent can identify the tool's high-level purpose but lacks enough local detail to confidently construct a valid bank movement payload.

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 both parameters. The description reinforces that data is sent verbatim and provides an external documentation link, but it adds little beyond what the schema fields state, especially for the nested data object whose allowed fields are not described.

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: 'creates a real bank movement in a treasury account,' and identifies the API version. It is clearly distinguishable from read-oriented siblings like list_bank_movements, but it does not explicitly contrast itself with reconcile_bank_movement or explain when this creation path is appropriate.

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 'WRITE' prefix signals a mutating operation, but there is no explicit guidance on when to use this tool versus alternatives such as create_treasury or reconcile_bank_movement. It also omits prerequisites, constraints, and when-not-to-use conditions for creating a real bank movement.

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

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

No annotations are provided, so the description carries the full burden. It signals a mutation only through the word 'Create' and gives no information about side effects, duplicate/tax-ID conflicts, error behavior, required permissions, or what the call returns --- all of which matter for a 9-parameter create tool with nested objects.

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?

Six words and a version tag for a tool with 9 parameters, a nested address object, and an array of contact persons. Nothing is wasted, but the definition is grossly under-sized relative to the operation's complexity 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?

Given no annotations, no output schema, and a nested-object payload, the description should explain creation semantics (what is returned, duplicate handling, whether type defaults apply). The API-version parenthetical is the only extra context provided, leaving significant gaps.

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

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

Schema description coverage is 100% and includes notable guidance (the 'code' vs legacy 'vatnumber' caveat, the type enum, nested contactPersons). The description adds nothing on top of the schema, so the baseline 3 applies.

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

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

The description states a specific verb and resource ('Create a new contact'), which an agent can match to the create/list/update/delete_contact family. It does not explicitly distinguish itself from siblings such as update_contact or create_contact_group, 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?

There is no guidance on when to use this rather than update_contact (for an existing contact) or create_contact_group, nor any prerequisites, duplicate-handling notes, or mention that only 'name' is required. The agent must infer everything 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?

No annotations and no output schema, so the description carries the full behavioral burden, yet it discloses only that a creation occurs. It says nothing about required permissions, duplicate-name behavior, idempotency, or what the response contains—significant gaps 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 wasted clauses. It is appropriately brief, though the API-version parenthetical contributes little for tool selection.

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

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

For a create operation with no annotations and no output schema, the description leaves key call-time facts undisclosed: what happens on duplicate names, whether auth scopes matter, and what is returned. A simple schema doesn't fully compensate for those behavioral omissions.

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 one parameter with 100% schema description coverage, so the schema already defines the meaning of 'name'. The description adds no additional semantic detail 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 (Create) and resource (contact group), which implicitly distinguishes it from the list_contact_group, get_contact_group, update_contact_group, and delete_contact_group siblings. The parenthetical API version is noise but doesn't obscure purpose.

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

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

No guidance on when to create a group versus using an existing one, no prerequisites, no mention of duplicate handling, and no explicit alternative named. The agent must infer usage from the verb 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?

With no annotations, the description bears full burden and excels. It discloses default approval, draft behavior, numbering override for sales, preservation for purchases, retention rules, expAccountId cascading, per-line account rejection, and permanent locking of approved 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?

The description is a single dense paragraph of five sentences covering many points without wasted words. It could be slightly improved with structure (e.g., bullet points), but it remains efficient and readable.

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, multiple behaviors), the description covers all key aspects: approval, numbering, retention, account cascading, and warning mechanism. No gaps are evident for typical use.

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?

Although schema coverage is 100%, the description adds significant value beyond schema descriptions by explaining the practical implications of approveDoc (default behavior, draft visibility), invoiceNum (override warning), retention (accepted/rejected), and expAccountId cascading.

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

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

The description clearly states 'Create a new document (invoice, estimate, purchase, etc.)' with a specific verb and resource. It lists the docType enum values, covering all document types, and distinguishes itself from sibling tools like update_document and delete_document.

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

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

The description provides explicit guidance on when to use approveDoc:false for drafts, explains numbering behavior for sales vs purchases, and notes retention acceptance/rejection. While it doesn't directly compare to alternatives, the context is clear enough for most use cases.

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

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

With no annotations, the description carries the full burden, and it does disclose two real traits: the operation is a write that creates a genuine (non-dry-run) record, and `data` is passed straight through with no validation or field mapping. It omits permissions/auth requirements, duplicate handling, and what happens on failure or success — meaningful gaps for an unannotated 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?

Two sentences with zero filler; the WRITE marker and the persistence fact are front-loaded, and the pass-through semantics follow 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 one-parameter write tool with no annotations and no output schema, the description should say more about the RESULT (does it return the created employee ID?) and about error or duplicate behavior. The external documentation link partially compensates for the free-form payload, but the return contract is entirely unaddressed.

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 defines only a free-form object with a terse description, so the field-level burden falls on the description. Saying the payload is 'sent verbatim as the request body' is valuable — it tells the agent there is no server-side transformation — and the external reference plus sample fields (name, email) gives a path to the required shape, though the agent must leave the context to get the full field list.

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 ('creates a real employee record in Holded') plus the API version. It differentiates against siblings implicitly by naming the resource 'employee record' rather than employee_time or salary_record, but never names an alternative tool 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 'WRITE:' prefix and 'real employee record' imply a persisting mutation, which is enough to infer when to use it over read tools like list_employees/get_employee. However, no exclusions are given — nothing about when to use update_employee instead, or preconditions such as whether the employee must not already exist.

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

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

With no annotations, the description carries the full burden; it does lead with 'WRITE', which correctly signals a mutation, and explains that `data` is forwarded verbatim. It does not disclose permission requirements, whether the operation is idempotent, error behavior, or what the call returns — gaps that matter 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?

Two compact sentences, mutation intent front-loaded in the first word, and no filler. The docs pointer is the only reference and it is doing necessary work for the free-form payload.

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

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

No output schema exists and the nested `data` payload is defined only by an external link, which the description correctly flags. Complete enough to call correctly, but an agent must leave the tool to learn the payload shape, and no failure or permission context is given.

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%, but `data` is a free-form nested object whose fields are undocumented in the schema; the description adds real value by stating it is sent verbatim as the request body and pointing to the exact API reference section for its shape. That is meaningfully beyond what the schema provides.

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

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

States a specific verb and resource: 'creates a manual time-tracking record for an employee', with API version provenance. The word 'manual' implicitly separates it from clock_in_employee/clock_out_employee, but the description never names a sibling explicitly, so an agent must infer the boundary itself.

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

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

'Manual' hints at the contrast with clock-in/clock-out/pause flows, which is a useful implicit cue. However, there is no explicit when-to-use / when-not-to-use statement and no named alternative such as update_employee_time or clock_in_employee, leaving routing to inference.

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

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

No annotations are provided, so the description carries the full burden, and it only implies a write operation via "Create". It says nothing about permission requirements, idempotency, duplicate-name/code handling, or what the call returns on success or 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?

One short sentence with zero waste and the verb front-loaded. Its brevity borders on under-specification, but nothing extraneous is present.

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

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

For a mutation tool with no annotations and no output schema, the description should disclose side effects or expected response, which it does not. The rich parameter schema offsets this somewhat, but the behavioral picture an agent needs to call a create endpoint safely 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%, and the schema itself carries the meaningful semantics (notably the `code`/`accountNum` mapping to list_expenses_accounts). The description adds no parameter meaning 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 ("Create") and resource ("expenses account"), so an agent knows the operation immediately. However it does not distinguish this from adjacent siblings such as create_accounting_account or create_bank_account, leaving the agent to infer which account 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 guidance on when to use this tool versus create_accounting_account, create_bank_account, or update_expenses_account. No prerequisites (e.g. existing chart of accounts, required permissions) or exclusions are mentioned.

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

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

No annotations exist, so the description carries the full burden. It does add real behavioral detail: the operation is a write, targets API v2, and `data` is passed through verbatim with no validation or transformation. It omits whether the created record is returned, what errors look like, and any permission or irreversibility notes.

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

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

Two short sentences with the operation type and destination front-loaded and no filler. The external link is compressed rather than inlined as a long URL block or prose.

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 a single required nested-object parameter, no annotations, and no output schema, an agent still lacks the payload fields and the success response shape. The description acknowledges this by deferring to the Holded API reference, which is honest but requires an outbound lookup before the tool can be called 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 coverage is 100% and the schema already states "Forecast payload, sent verbatim as body," which the description largely repeats. The added value is the external API reference link, which is the only route to the nested object's field semantics since the schema defines no properties.

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 ("creates an invoicing forecast in Holded cashflow") and flags it as a WRITE, which cleanly separates it from get_invoicing_forecast, list_invoicing_forecasts, update_invoicing_forecast and delete_invoicing_forecast. It stops short of naming those siblings explicitly, so differentiation is implicit in 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 "WRITE:" prefix implies when the tool applies (creating new vs. updating existing forecasts) and the docs pointer tells the agent where to resolve the payload shape, but there is no explicit statement of prerequisites, when-not-to-use, or a named alternative such as update_invoicing_forecast.

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

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

With no annotations, the description carries the full burden and does disclose the key traits: it is a real write to production books, incorrect entries distort the company accounts, and the payload is forwarded verbatim. Missing are idempotency/duplicate behavior, auth or scope requirements, and what the call returns 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?

Three short sentences, front-loaded with the WRITE verb and the consequence warning immediately after. No filler, and the external reference is the last item where it belongs.

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 write tool with a nested unstructured body, no annotations and no output schema, the description covers risk and payload handling but leaves the actual body shape entirely to an external URL. An agent cannot construct a valid entry from the definition alone, which is a meaningful gap.

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

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

Schema coverage is 100% and there is only one parameter, so the baseline is 3. The description does add genuine meaning by stating the object is sent verbatim as the request body and pointing to the official endpoint reference for field structure, but it never enumerates or constrains the nested fields an agent must supply.

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?

Names a specific verb and resource (creates a journal entry), pins the target system and API version, and prefixes with an explicit WRITE marker that separates it from read-side siblings like list_ledger_entries. Nothing about intent is ambiguous.

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 conveys the context (booking a journal entry in Holded accounting) and warns to double-check accounts and amounts, but never states when to prefer this over alternatives or what prerequisites exist — e.g. whether accounts must exist first via list_accounting_accounts, or how it relates to list_ledger_entries.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about side effects, whether serie names must be unique per docType, what happens on conflict, or what permissions are required. Only the word "Create" signals a mutation, which the tool name already conveys.

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

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

It is a single short sentence, but it is under-specified rather than efficient — there is no front-loaded detail an agent could act on and the parenthetical adds no operational 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 four-parameter mutation tool with no annotations and no output schema, the description should at minimum explain what is created and any constraints or return shape. It provides none of that, leaving the agent to rely solely on schema field names.

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 four parameters (name, prefix, docType, nextNumber) documented in the schema including a full enum for docType. The description adds no semantics beyond that, 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 verb and resource ("Create a new numbering serie"), so the basic action is identifiable, but it adds nothing beyond what the tool name already says and does not distinguish it from siblings such as get_numbering_series, update_numbering_serie, or delete_numbering_serie. The parenthetical "(Holded API v2)" is provenance, not purpose.

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

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

There is no guidance on when to create a serie versus updating an existing one, no mention of prerequisites (e.g., that docType determines which documents the serie applies to), and no reference to any alternative tool. The agent must infer usage entirely from the name.

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

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

No annotations are supplied, so the description carries the full burden, yet it only names the API version (v2). It says nothing about whether duplicates are rejected, what permissions are required, whether the created entity is immediately visible to list_payments, or what the response contains.

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

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

It is a single short sentence with no waste and the resource is front-loaded, but the brevity comes at the cost of under-specification rather than efficient density. The "(Holded API v2)" parenthetical is the only content beyond the title.

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

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

For a two-parameter mutation tool with no annotations and no output schema, the description should at minimum disambiguate the entity created and note mutation/auth behavior. Neither is present, leaving the agent dependent entirely on 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 the baseline is 3: both parameters ("name", "days") are documented inline. The description adds no extra meaning, and notably does not resolve the conflict between "payment" in the description and "Payment method name" in the schema.

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

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

The verb+resource is stated ("Create a new payment"), which is more than a tautology, but the term "payment" is ambiguous against the schema, which describes a payment *method* (required field is "Payment method name", plus "days until due"). No distinction is drawn from siblings like update_payment, list_payments, or list_payment_methods, so an agent cannot confidently tell which entity is being created.

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 prerequisite or permission context, and no named alternative. With siblings including list_payment_methods, update_payment, and get_document_payments, the agent is left to guess whether this creates a payment record or a payment method.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers almost nothing. It does not state that only 'name' is required, what happens if the SKU already exists, whether the call is idempotent, what permissions are required, or what the response contains. 'Create' implies mutation but nothing else is disclosed.

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

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

A single short sentence with the verb front-loaded and zero waste. Efficiency here comes at the cost of substance, but structurally it is clean and not padded.

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

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

With 9 parameters, no annotations, and no output schema, the description should do meaningful work. It omits the required-parameter constraint, default behavior for stock/price/tax, and the return value shape – leaving an agent to reverse-engineer semantics from the schema alone before a mutating 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% – all nine properties carry inline descriptions including the product/service enum for 'kind'. The description adds no additional meaning beyond the schema, so baseline 3 applies. It could have added value by highlighting that only 'name' is mandatory.

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 product'. An agent knows immediately what the tool does. However, it does nothing to distinguish itself from siblings like update_product, list_products, or create_service, which share the same product domain.

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_product, create_service, or list_products. The parenthetical '(Holded API v2)' is provenance, not usage direction. The agent has to infer everything 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?

With no annotations, the description carries the full burden and does disclose the key trait: the call writes a real payroll record affecting accounting and HR data, and `data` is sent verbatim. It leaves out auth/permission requirements, error behavior on invalid payloads, and what the response returns, keeping it short of a 5.

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

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

Three short clauses, front-loaded with the WRITE marker and the highest-stakes fact (real payroll/accounting impact), followed by the prerequisite and the payload pointer. Nothing 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 mutation tool with a free-form nested body, no annotations and no output schema, the description covers impact, prerequisite, and where to find the payload spec. Missing only response/return behavior and permission scope to be fully complete.

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

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

Schema coverage is 100%, so baseline is 3, and the description adds real value by explaining the single param is passed verbatim as the request body and by pointing to the external API reference and defaults tool for the nested object's expected shape — something the flat schema cannot express.

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 ('creates a real payroll record in Holded') plus the API version, and the 'WRITE' prefix makes the mutating nature unmistakable against read siblings like get_salary_record or list_salary_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?

It explicitly names a prerequisite path — 'Use get_salary_record_defaults first to obtain a valid base payload' — which routes the agent to the right sibling before calling. It doesn't spell out the create-vs-update decision, but the verb plus the defaults prerequisite gives clear context.

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

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

No annotations are provided, so the description carries the full behavioral burden and does not meet it. It doesn't state whether the name must be unique, whether duplicates are rejected or merged, what permissions are needed, or whether the created channel is returned with an ID.

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

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

A single short sentence with no padding, though the parenthetical '(Holded API v2)' is metadata rather than guidance an agent needs to select or call the 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?

This is a mutation tool with no annotations and no output schema. The description should say what a successful call yields (e.g. the new channel's ID) and any constraints on the name, and it says neither.

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

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

Schema coverage is 100% and there is only one parameter, 'name', which the schema already documents as 'Sales channel name.' The description adds no 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 and resource: 'Create a new sales channel.' The create/list/get/update/delete siblings are distinguished by name alone, so the description doesn't need to do that work, but it also adds nothing beyond the name itself.

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

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

No indication of when to use this versus update_sales_channel or how it relates to list_sales_channel. No prerequisites, no duplicate-handling guidance, no 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?

No annotations are provided, so the description carries the full burden. It does not disclose what happens on duplicate names/SKUs, whether the call is idempotent, what permissions are needed, or what the response contains — significant gaps 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 padding; the '(Holded API v2)' parenthetical is the only near-wasted token. Brevity here reflects terseness rather than sprawl.

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

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

The description should do more for a five-parameter mutation tool with no annotations and no output schema. It never says what is returned (e.g., the created service with its id) or which fields matter most, leaving the agent to infer the post-call state.

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 fields (name, sku, tax, price, description) are already documented in the schema. The description adds no meaning beyond that; baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Create a new service'), which is enough to distinguish it from list_services, get_service, update_service and delete_service by verb alone. Sibling differentiation is implicit rather than explicit, so it falls 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?

There is no guidance on when to use this tool instead of update_service or create_product, no prerequisites, and no note about required permissions. The only routing signal is the verb 'create'.

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

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

No annotations are provided, so the description carries the full disclosure burden. It says 'create' (a mutation) but omits required permissions, duplicate-name behavior, whether an initial balance impacts anything downstream, and what the call returns — the only extra context is the API version tag.

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 purpose sentence is front-loaded and efficient, but the second sentence is internal roadmap/consolidation commentary that doesn't help the agent call the tool correctly, weakening the 'every sentence earns its place' test.

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 mutation tool with no annotations and no output schema, the description should cover side effects, return shape, and failure modes. It covers none of these, leaving the agent without what it needs to invoke 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% and all four fields (bic, iban, name, balance) are documented in the schema itself. The description adds no parameter meaning 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+resource: 'Create a new treasury account', plus API provenance (Holded API v2). It names the overlapping siblings (list_bank_accounts/get_bank_account/create_bank_account), so an agent can see potential alternatives, though it doesn't resolve which to prefer.

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 overlap note flags that alternatives exist but gives no condition for choosing this tool over create_bank_account, nor any prerequisites. 'Consolidation planned for 2.1' is internal roadmap trivia, not when-to-use guidance, and arguably leaves the agent more uncertain about which tool to pick.

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

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

No annotations are provided, so the description carries the full burden and it drops it: nothing about what the call returns, whether the name must be unique, what happens on duplicate/permission errors, or which fields are optional beyond the schema's `required` list. Only "Create" hints that this is a 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 no filler; the parenthetical API version is mild overhead but not wasteful. Efficient, though it is efficient at saying very little.

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

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

For a mutation tool with no annotations and no output schema, the definition should say what a successful create yields (an id? the full warehouse object?) and any constraints on the name. Those gaps are not covered anywhere else in the structured data.

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 six plainly named fields (name required, address fields optional), so the schema does the parameter work. The description adds no semantics beyond it — no format hints for country/province/postalCode or whether name collisions are rejected.

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?

Names a specific verb and resource ("Create a new warehouse") plus the backing API version. The CRUD naming and the presence of update_warehouse/delete_warehouse siblings make the intent unambiguous, though the description never names those siblings 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?

No statement of when to use this versus update_warehouse, create_product, or the other create_* tools, and no prerequisites (auth, account scope, whether the warehouse must be unique by name). The agent must infer usage from the verb 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?

With no annotations, the description carries the full safety burden and does so well by labeling the tool DESTRUCTIVE and stating that the deletion cannot be undone. It stops short of explaining side effects on related records such as bank movements, but the core irreversibility warning is explicit.

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

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

The description is three short sentences with no wasted text. It front-loads the destructive warning and immediately follows with the safer alternative.

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

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

For a simple one-parameter delete operation with no output schema, the description contains everything needed: what it deletes, that it is permanent, and which safer sibling to use instead. No critical context is missing for correct tool selection.

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 only one parameter and schema description coverage is 100%, so the schema already defines accountId sufficiently. The description does not add format or behavioral detail about the identifier beyond what the schema provides, which matches the baseline for high schema coverage.

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 and resource: permanently deletes a treasury bank account in Holded. It also distinguishes this tool from the sibling archive_bank_account, so an agent can tell exactly what this operation is for.

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

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

It explicitly routes the agent toward the safer alternative: prefer archive_bank_account to keep history. This makes the when-to-use-this-vs-alternative decision clear without needing to infer it 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?

With no annotations, the description alone must carry the full behavioral burden for a destructive operation, but it only repeats the action verb. It does not say whether deletion is permanent or soft, what happens to associated documents or attachments, or whether confirmation is required. Because it does not contradict anything, this is 2 rather than 1.

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 short phrase with the action front-loaded and no wasted words. It is efficient, though its brevity leaves required context uncovered rather than including too much.

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 mutation with no annotations and no output schema, the description is too thin. It omits permission requirements, irreversibility, side effects on related records, and the expected response. This is not enough for an agent to invoke the tool safely.

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 single contactId parameter is already fully documented. The description adds nothing about the ID format or its source. A baseline of 3 applies because the schema does the documentation work.

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: "Delete a contact." This is distinct from siblings like delete_contact_group or delete_product because it names the target resource explicitly. It does not, however, explain how it differs from those adjacent delete tools, which keeps 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?

It gives no guidance on when to use this tool, what prerequisites apply (such as the contact existing), or what alternatives exist. There is no warning that deletion is permanent, and no instruction on verifying the contact 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether deletion is permanent, what happens to associated contacts, or what permissions are required. For a destructive operation, this is a significant gap.

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

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

The description is a single short sentence with no wasted words and is front-loaded. It could be slightly more informative without sacrificing conciseness, but it is appropriately 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?

For a destructive tool with no annotations and no output schema, the description lacks essential context such as irreversibility, side effects, or error conditions. It is incomplete for an agent to call it safely.

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 provides 100% description coverage for the single 'groupId' parameter, so the baseline is 3. The description adds no additional meaning beyond what the schema already documents.

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 ('Delete a contact group'), making the action unambiguous. It does not explicitly differentiate from siblings like update_contact_group, but the intent is clear from the name 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 versus alternatives, no mention of prerequisites, and no indication of when deletion is appropriate. The description merely restates 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?

The description only states the obvious destructive nature of the operation, without disclosing any side effects, permanence, or authorization requirements. With no annotations, more behavioral context is needed.

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?

While extremely short, the description fails to provide useful information beyond the tool name, making it insufficiently informative for its length.

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

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

Given the lack of annotations and output schema, the description does not adequately explain the implications of deletion (e.g., reversibility, effects on related data), leaving the agent underinformed.

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

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

Schema coverage is 100% and the schema already describes both parameters. The description adds no additional meaning, so the baseline score 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?

The description 'Delete a document' is a tautology that merely restates the tool name, with no additional specificity about the document types involved that could distinguish it from similar delete tools for other entities.

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

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

No guidance is provided on when to use this tool versus alternatives, such as prerequisites, required permissions, or conditions for deletion.

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

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

With no annotations provided, the description carries the full burden and does well: it declares destruction, permanence, and irreversibility upfront. It does not mention permission requirements or side effects on related records (e.g., salary records, time entries), which keeps it short of a 5.

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, zero padding, and the destructive warning is front-loaded so the agent sees the risk before anything else.

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

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

For a single-parameter destructive tool with no output schema, the essential information (permanent, irreversible, scoped to an employee record) is present. Missing only ancillary details such as authorization needs or downstream effects on linked records.

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

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

There is only one parameter and schema description coverage is 100%, so the schema already documents employeeId. The description adds no format hints or constraints beyond that, 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 uses a specific verb (permanently deletes) and resource (an employee record in Holded, API v2), so it is clearly differentiated from temporal siblings like delete_employee_time. It stops short of explicitly contrasting itself with sibling deletion tools, but the resource 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?

It states that the operation is destructive and irreversible, but gives no guidance on when to choose this over alternatives such as update_employee for deactivation, nor any prerequisites. The agent has to infer usage context 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?

With no annotations provided, the description carries the full load and does disclose the most important behavioral trait: the operation is destructive and irreversible. It also names the target system and API version. It omits what permissions are required and what happens to records on failure, so it is strong but not complete.

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

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

Two short sentences, with the destructive nature front-loaded before the resource and the irreversibility caveat. Nothing 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 single-parameter delete with no output schema, the description covers the essential facts: what is deleted, that it is permanent, and which system it applies to. Missing only secondary detail such as permission requirements or behavior on an invalid ID.

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 100% description coverage for the single timeId parameter, so the baseline is 3. The description's phrase 'time-tracking record' adds a small amount of framing but no format, source, or lookup guidance beyond what the schema already says.

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 (permanently deletes) and resource (a time-tracking record in Holded), which cleanly separates it from get_employee_time, update_employee_time, and list_employee_times. It does not explicitly name a sibling it should be preferred over, but the delete semantics make the distinction obvious.

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 DESTRUCTIVE and the irreversibility warning imply caution, but the description gives no explicit guidance on when to delete versus update or archive a time record, and names no alternatives. Usage is inferred from the verb rather than stated.

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

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

No annotations are provided, so the description carries the full behavioral burden for a destructive mutation. Beyond the word 'Delete', it discloses nothing about irreversibility, required permissions, failure modes for accounts in use, or confirmation 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 short sentence with the verb and resource front-loaded and no filler; the '(Holded API v2)' parenthetical is minor but harmless. It is terse rather than padded.

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 tool with a fully documented schema and no output schema, the structural information is adequate. However, as an unannotated destructive operation it should say more about consequences and error conditions before an agent commits to calling 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% with a single well-described `accountId` parameter, so the baseline is 3. The description adds no extra meaning (e.g., where to obtain the ID), leaving the schema to do all the work.

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+resource ('Delete an expenses account'), which is unambiguous and lets an agent distinguish it from the list/create/get/update_expenses_account siblings. It doesn't explicitly name those alternatives, but the operation is clear from the name and description.

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 the other expenses-account tools, no prerequisites, and no mention of what happens if the account still has movements or associations. The agent must infer the whole usage context from the tool 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?

With no annotations, the description carries the full burden, and it does disclose the single most important trait: the deletion is permanent and cannot be undone. It omits everything else an agent needs — whether linked cashflow records cascade, error behavior for a missing/invalid forecastId, and what (if anything) is returned.

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 that leads with the destructive warning — the highest-value information for an agent deciding whether to call it. Zero padding.

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?

Small surface area (one required param, no output schema, no nesting) means little needs explaining, and the irreversibility warning is the crucial piece. Slightly short of complete because it says nothing about failure modes or outcome, which matter for a destructive operation with no annotations.

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

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

Only one parameter (forecastId) and schema description coverage is 100%, so the schema already documents it fully; this is the baseline case. The description adds no format hints (e.g. ID shape) or guidance on obtaining the ID from list_invoicing_forecasts, so it does not exceed 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?

Specific verb + resource: 'permanently deletes an invoicing forecast' plus the domain 'Holded cashflow (API v2)'. An agent can distinguish it from get_invoicing_forecast / update_invoicing_forecast / list_invoicing_forecasts by name alone, though the description never explicitly routes to 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?

Usage is only implied: the delete verb plus the 'DESTRUCTIVE' prefix signal caution, but there is no explicit when-to-use vs. when-not guidance, no mention of the alternative (e.g. update_invoicing_forecast to modify rather than remove), and no prerequisites such as required permissions.

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

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

With no annotations at all, the description carries the full behavioral burden and largely defaults to it. It does not state that the operation is irreversible, whether deletion fails when documents reference the series, what error shape to expect, or what permissions are required. The 'Holded API v2' suffix is citation, not 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 the verb first and no filler; it is easy to parse. The parenthetical API version adds little, but nothing is padded or buried.

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 two-parameter mutation with no annotations and no output schema, the description should say more about consequences and failure modes. An agent knows what it deletes but not what it risks or what it will get back.

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

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

Schema coverage is 100% and both parameters are documented in the schema, including an 11-value enum for docType, so the baseline of 3 applies. The description adds no meaning beyond the schema — it does not explain why the document type must accompany the serie id or how the pair is scoped.

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?

Specific verb (Delete) plus specific resource (numbering serie), and the (Holded API v2) tag scopes the API generation. It is clearly distinguishable from get/create/update_numbering_serie siblings by the verb alone, but the description never names or contrasts 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?

No when-to-use, when-not-to-use, or prerequisite guidance. There is no warning about deleting a series that may be assigned to documents, and no pointer to the safer siblings (get_numbering_series, update_numbering_serie) for callers who only want to inspect or modify.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It conveys only that the operation is destructive; there is no mention of irreversibility, required permissions, side effects on linked documents/ledger entries, or error behavior for a nonexistent or in-use payment.

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 front-loaded and zero filler. It is efficient, though the brevity borders on under-specification for a destructive operation.

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

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

For a destructive tool with no annotations and no output schema, the description should warn about irreversibility and downstream effects (e.g., on documents or ledger entries). Those are absent, leaving an agent unable to assess risk before calling 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?

With a single required parameter at 100% schema description coverage, the schema fully documents paymentId. The description adds no format, ID-source, or validation 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 and resource ("Delete a payment") with API version context, which clearly separates it from siblings like update_payment, get_payment, list_payments, and delete_document. It does not explicitly name any sibling as an alternative, but the distinction is unambiguous from the verb.

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

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

No guidance on when to use this versus update_payment, delete_document, or other payment operations, and no preconditions stated (e.g., whether a payment linked to a document can be deleted). The agent must infer everything from the name.

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

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

With no annotations, the description carries the full behavioral burden, yet only the verb "Delete" implies destructiveness — information already in the name. It says nothing about irreversibility, required permissions, or side effects on related images, stock, or documents that reference the product.

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 clause with the action front-loaded and zero filler. Its brevity is efficient, though it borders on under-specification for a destructive operation.

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

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

For a destructive, non-annotated tool with no output schema, the description is too thin — it omits permanence warnings, failure conditions, and what happens to dependent resources. An agent could invoke it correctly but without understanding the 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?

The single parameter is fully documented in the schema (100% coverage, "Product ID to delete"). The description adds no format, sourcing, or lookup guidance, 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 and resource ("Delete a product"), which is unambiguous. However, it offers no differentiation from siblings like delete_service, delete_document, or delete_warehouse, and the "(Holded API v2)" tag is provenance rather than disambiguation.

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_product, or archived alternatives. No prerequisites stated, such as whether the product must have no pending documents or stock before deletion.

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

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

With no annotations, the description carries the full burden and does well by disclosing permanence, irreversibility, and impact on accounting data. It stops short of mentioning permission requirements, related-record side effects, or the return value, which would push it to a 5.

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

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

Two sentences, front-loaded with the critical 'DESTRUCTIVE' tag, no wasted words, and essential warnings immediately visible.

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

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

For a simple one-parameter delete tool with no output schema or annotations, the description covers the critical safety profile (destructive, irreversible, affects accounting). It could mention return behavior or auth requirements, but is nearly complete.

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

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

Schema description coverage is 100% and the single parameter (salaryRecordId) is documented in the schema. The description adds no extra meaning about the ID's format or source, 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 (permanently deletes) and a specific resource (payroll record), with additional context (Holded API v2). This clearly distinguishes it from siblings like delete_employee_time or update_salary_record.

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 'DESTRUCTIVE' warning and 'cannot be undone' imply caution, suggesting the tool should be used only for permanent removal. However, it does not explicitly state when to use this versus update_salary_record or other siblings, nor does it name alternatives.

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

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

No annotations are provided, so the description carries the full burden. It says 'delete' but does not disclose whether deletion is permanent or reversible, what permissions or scopes are required, what happens to dependent records, or what an error looks like — all critical for a destructive operation.

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

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

A single terse sentence with no wasted words, and the verb plus resource are front-loaded. It is arguably too brief rather than padded, so the structure 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 destructive single-parameter tool with no annotations and no output schema, the description should at minimum mention irreversibility, required permissions, or failure behavior. None of that is present, leaving the agent under-informed about the consequences of calling 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?

The single parameter is fully documented in the schema (ID of the sales channel to delete) at 100% coverage. The description adds no extra meaning such as ID format or where to obtain the ID, 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 (delete) and resource (sales channel) plus API version context, so the action is unambiguous. It does not explicitly distinguish itself from siblings like list_sales_channel, create_sales_channel, or update_sales_channel, though the verb makes the intent obvious.

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 the other sales_channel tools, no prerequisites stated, and no caveats about when deletion is appropriate. The agent must infer everything from the tool name and schema.

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

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

No annotations are provided, so the description carries the full burden and falls well short. It does not say whether deletion is permanent or reversible, what happens if the service is referenced by invoices, whether confirmation or elevated permissions are required, or what a successful response 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?

One short, front-loaded sentence with no filler. Its brevity is efficient rather than padded, though it is arguably too thin 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?

This is a destructive mutation with no annotations, no output schema, and no explanation of failure modes or consequences. For a delete operation, the description should disclose far more than it does.

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 at 100% schema description coverage ('Service ID to delete'), so the schema already fully documents it. The description adds no meaning 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 and resource ('Delete a service'), which distinguishes it cleanly from create_service, update_service, get_service and list_services in the sibling list. The API version tag adds identifying context, though no explicit sibling routing is given.

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 update_service or the other lifecycle operations, and no preconditions such as whether the service must be unused by documents. The agent must infer everything about appropriate timing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure for a destructive mutation. It says nothing about irreversibility, required permissions, what happens to associated stock records (list_warehouse_stock exists), or whether the call fails if the warehouse is in use.

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 sentence is short and front-loaded with the action and resource, with no filler. Its brevity is not bloated, though the parenthetical API-version tag contributes little.

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

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

For a destructive, non-annotated tool with no output schema, the description should at minimum confirm the effect and any caveats. Instead it offers a four-word restatement, leaving the agent without the information needed to call it safely.

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 warehouseId parameter, so the schema already explains the input. The description adds no format hints (ID shape, where to obtain it) beyond what the schema provides, 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?

"Delete a warehouse" names a verb and a resource, but it is essentially a restatement of the tool name with an API-version tag appended. It gives no scope details (hard vs soft delete, what a warehouse represents in Holded) and does not distinguish it from the sibling delete_* tools beyond the resource noun.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as update_warehouse or list_warehouses for verifying the target first. The agent must infer everything 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?

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a read operation, but the description says nothing about permissions, error behavior when the ID is missing, or what information is returned.

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 is appropriately sized for a simple one-parameter retrieval 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 simple get-by-ID tool, the description is minimally adequate. However, with no annotations and no output schema, it could usefully clarify what is returned or how missing accounts are handled.

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 single accountId parameter is already documented as 'Bank account ID'. The description adds only the phrase 'by ID', which confirms the parameter's role but contributes no format or syntax detail beyond the schema.

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

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

The description states a specific verb and resource ('Get a ... bank account') and scopes it to retrieval 'by ID'. This implicitly separates it from the list/create/update/delete bank-account siblings, though calling it a 'treasury bank account' slightly blurs the line with the separate treasuries tools.

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 statement of prerequisites, and no mention of alternatives such as list_bank_accounts. The phrase 'by ID' weakly implies the required input but does not tell the agent 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?

With no annotations, the description carries the behavioral burden and does so well: it declares the tool read-only, explains cursor pagination, describes the returned account fields, and clarifies that all account groups are included. It stops short of covering auth requirements or rate limits, but the core behavior is disclosed.

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

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

The description is front-loaded with the purpose and return shape, then moves into pagination, filters, and sibling notes. Most sentences earn their place; the consolidation note is slightly extraneous but useful for disambiguating a duplicate 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 six-parameter read-only list tool with no output schema, the description is complete enough: it describes return fields, pagination handling, optional filters, account-group scope, read-only behavior, and sibling alternatives.

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 baseline is 3. The description adds meaning beyond the schema by explaining that `start_date`/`end_date` filter by activity period, that `include_empty` includes zero-balance accounts, and that `cursor` should be taken from the previous response's `nextCursor`.

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 ('Get accounting accounts'), identifies the underlying API endpoint, and lists the returned fields. It also explicitly distinguishes this tool from the sibling `list_expenses_accounts` by noting that this one includes all account groups rather than group-6 only.

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

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

It gives a clear contrast with `list_expenses_accounts` and explains that the tool covers all groups. It also names `list_accounting_accounts` as a same-endpoint alternative and mentions planned consolidation, though it does not fully tell the agent which duplicate to choose in practice.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing beyond the operation itself. It is silent on error behavior for unknown IDs, authentication needs, and what a returned contact includes; the only added context is an API version tag.

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; the operation and its selector appear immediately. The parenthetical API version is a minor extra but costs nothing.

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 getter with full schema coverage this is close to sufficient, but with no output schema the description could have indicated what a contact record contains or what happens on a bad ID. It is minimally viable 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% for the single contactId parameter, so the schema already documents it fully. The description's "by ID" merely restates the schema and adds no format or sourcing detail (e.g., where to obtain a contactId).

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 a specific contact") and adds the selector ("by ID"), which implicitly separates it from the sibling list_contacts. It does not explicitly name its siblings, but the single-record-by-ID scope 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?

Usage is only implied: the agent must infer that this tool is for when a contactId is known and that list_contacts is the alternative for discovery. No explicit when-to-use or when-not-to-use guidance is given.

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

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

No annotations exist, so the description carries the entire behavioral burden. It discloses the v1-to-v2 signature change, but says nothing about what the call returns (file bytes vs. metadata), whether the attachment is downloaded or merely referenced, or what happens on an unknown filename — significant gaps for a fetch tool with zero annotation coverage.

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

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

Three short sentences, front-loaded with the core action and the alternative tool. The breaking-change note is marginally tangential for an agent with no v1 context, but it is compact and does not bloat the definition.

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?

Both required parameters are documented and the prerequisite tool is named, which is enough to invoke it. However, with no output schema and no annotations, the description leaves the return value and error semantics unstated — the main remaining deficiency for a simple two-parameter fetch.

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 are already documented, including that filename comes from list_contact_attachments. The description's note that filename is the path parameter and the historical change from attachmentId adds minor context but largely repeats 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+resource (get a specific attachment from a contact) narrowed by an explicit lookup key (filename), and names the sibling list_contact_attachments that produces that key. This lets an agent distinguish it from the listing tool without opening either schema.

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

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

Gives a concrete ordering requirement: 'Obtain filenames from list_contact_attachments first,' which routes the agent to the sibling tool. It doesn't state failure behavior or when this tool should not be used (e.g., missing contact), so it stops short of full when/when-not coverage.

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

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

No annotations exist, so the description carries the full burden, and it discloses almost nothing beyond 'Get' – no statement on read-only safety, permission requirements, or what happens when the ID is unknown. 'Holded API v2' is provenance, not behavior.

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

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

A single front-loaded sentence with the resource named first and no filler. It is terse to the point of thinness, but nothing is wasted.

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

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

For a one-parameter read lookup with full schema coverage and no output schema, this is minimally sufficient to call the tool. It is missing the returned-object note and error behavior that would make it fully self-contained.

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 describes groupId fully. The description's 'by ID' adds only a mild restatement of the required key; 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 ('Get a specific contact group') plus the lookup key ('by ID'), which sets it apart from sibling list_contact_groups. It never explicitly names siblings, but the singular/plural distinction is inferable from the wording.

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 gathers that this is the ID-based lookup rather than the list endpoint. There is no explicit statement of when to prefer it over list_contact_groups, nor any prerequisite or failure guidance.

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

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

No annotations exist, so the description carries the full burden and does so: it declares the tool read-only, warns the v2 API returns 422 without both bounds, documents automatic timestamp conversion and ISO precedence, and flags that `groupByEntry` is applied page-scoped — a genuinely non-obvious caveat.

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

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

Front-loads purpose and return shape, then uses a short bulleted block for the date-form rules and a compact paragraph for pagination/grouping. Slightly dense but every sentence carries operational information.

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

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

For a 7-parameter, no-annotation, no-output-schema tool, the description covers purpose, return fields, required argument combinations, precedence, error behavior, pagination, and the grouping mode. An agent could invoke it correctly without opening 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 coverage is 100%, so baseline would be 3, but the description adds real meaning beyond the schema: the dual date-input forms, their precedence order, and the page-scoped nature of `groupByEntry`. Pagination interplay between `limit` and `cursor` is left to 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 and resource ('Get ledger entries / journal for a date range') plus the exact API endpoint, and lists the returned fields. It names the sibling `list_ledger_entries` and admits both hit the same endpoint, but never says which to prefer, so differentiation is only partial.

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

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

Gives concrete operational guidance: at least one bound per date form is required, ISO takes precedence over the legacy Unix form, and `cursor`/`nextCursor` drives pagination. It lacks explicit when-to-use guidance against `list_ledger_entries`, which is the one clear gap.

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

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

Annotations are absent, so description must fully disclose behavior. It only says 'Get a specific document by ID' without stating it is read-only, what happens on failure (e.g., 404), or authentication requirements. Minimal 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?

Single short sentence with no superfluous words. Efficient, but could include more information without becoming verbose.

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

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

Tool has two required parameters and no output schema. Description lacks details about expected output format, error handling, or any limitations. Incomplete for an agent to fully understand the tool's behavior.

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

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

Schema coverage is 100%, so baseline is 3. Description adds no extra meaning beyond what is in the schema; does not explain the enum values of docType or the format of documentId.

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

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

Description clearly states the tool retrieves a specific document by ID, using action verb 'Get' and specifying resource 'document'. It differentiates from sibling tools like list_documents (list all) and get_document_pdf (get PDF).

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

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

No guidance on when to use this tool versus alternatives such as get_contact or get_product. Does not mention any prerequisites or context for invocation.

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

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

No annotations are provided, so the description carries the full burden; it does declare 'Read-only' and, more valuably, discloses a genuinely non-obvious behavioral trait — the return shape is unstable, yielding `{documentId, paymentsDetail}` only when the v2 response includes that field, otherwise the whole document. It stops short of covering failure modes (invalid docType, missing document, pagination) or auth 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?

Three sentences, front-loaded with the core action and followed by the return-shape caveat and the sibling comparison. The 'via the Holded API v2 GET endpoint' clause is mildly redundant but signals endpoint version, which contextualizes the field-name warning.

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

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

With no output schema and no annotations, the description compensates by explaining the possible return shapes and the read-only nature. Remaining gaps are error behavior and what happens across the 11 document types, but for a two-param read tool it is largely complete.

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

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

Schema coverage is 100% and the docType enum is fully enumerated in the schema, so the description adds nothing about parameter meaning beyond what the input schema already provides. Baseline 3 is appropriate 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 ('Get') and resource ('payments registered against a specific document'), and explicitly distinguishes itself from the nearest sibling by naming list_payments and its fiscal-year restriction. An agent can tell exactly what this returns without opening the schema.

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

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

Names the alternative (list_payments), states the differentiating condition (list_payments is scoped to the ACTIVE fiscal year; this spans ANY year), and gives a concrete use case ('cross-year payment audits'). That is the routing decision an agent needs.

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

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

With no annotations, the description carries the full burden and does well: it discloses the exact response payload keys and warns that unsupported types fail with a 404 rather than an empty result, which prevents a wasted retry loop. It does not cover auth/permission requirements or payload size limits for large PDFs, keeping it below a 5.

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

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

Front-loaded with purpose and return shape, then constraints. Every sentence carries real information, though the full docType enumeration partially duplicates the schema enum and could have been compressed if brevity were paramount.

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 two-parameter read tool with no output schema, the description supplies what the schema cannot: the decoded response structure and the known failure mode for unsupported document types. An agent has everything needed to call it correctly and interpret the result.

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 enum and documentId are already documented structurally. The description restates the docType values and adds the useful caveat that purchase is excluded, but adds no new meaning for documentId — 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 ('Get the PDF of a document') plus the encoding format and API version. The named return shape ({ contentType, base64, bytes, filename }) makes it unmistakable from get_document, which returns document data rather than a binary artifact.

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 an explicit supported docType list and an explicit exclusion: 'purchase is NOT supported — GET /purchases/{id}/pdf returns 404', plus a note that purchaserefund has no v2 CRUD support. That is clear when/when-not guidance; what's missing is a pointer to a fallback tool for purchases, so it stops short of the top score.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only lookup and gives an API version, but says nothing about behavior on missing/invalid IDs, permissions/scopes, or rate limits.

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

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

A single front-loaded sentence with the key scope ('single employee') first. The '(Holded API v2)' parenthetical is mildly dispensable but not costly.

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, schema-complete lookup with no output schema, this is minimally adequate. It leaves open what is returned and how not-found cases behave, which an agent would want to know before calling.

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

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

Schema coverage is 100% and the schema already specifies employeeId as a 24-char hex ObjectId; the description's 'by ID' adds nothing beyond that. Baseline 3 applies since 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?

Specific verb+resource: 'Get a single employee by ID'. The word 'single' implicitly distinguishes it from list_employees, but no sibling is named explicitly.

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

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

No statement of when to use this versus list_employees or get_employee_contract, and no prerequisites (e.g., needing an ID obtained from list_employees). Usage is only inferable from '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?

With no annotations, the description carries the full disclosure burden, and the 404 semantics note is genuinely valuable non-obvious behavior — it prevents an agent from misdiagnosing a bad employee ID. It stops short of covering permissions, rate limits, or what the payload contains, so it is not fully comprehensive.

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, the core action front-loaded and the 404 caveat placed immediately after. Every clause earns its place with no 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?

There is no output schema and no annotations, so the description would ideally say what the contract payload contains (fields, structure) and whether reads require scoping to the account. The 404 note covers the most likely failure mode, but the return-value side is 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?

The schema has 100% description coverage for the single employeeId parameter, so the schema already documents it. The description adds no format, source, or example detail beyond confirming that an employee ID is the input key.

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 the contract details of an employee") and narrows scope to contracts, which separates it from get_employee and update_employee_contract. It does not explicitly name those siblings, so differentiation is implicit rather than spelled out.

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

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

Usage is only implied by the resource name: an agent can infer this is the read path for contract data. There is no explicit statement of when to prefer it over get_employee, nor any precondition such as the employee having a contract, though the 404 note hints at that case.

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

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

No annotations are provided, so the description carries the full burden. It confirms a read of a single record but says nothing about read-only semantics, not-found error behavior, authentication requirements, or what the fetched record contains.

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

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

One short sentence, front-loaded with the verb and resource, with no waste. It is efficiently sized for such a simple tool, though the API version parenthetical adds little for tool selection.

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

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

The tool is simple: one required ID parameter and no output schema. The description covers the core action but omits error behavior and any hint of the returned record's shape, leaving modest gaps without an 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 coverage is 100%, so the single timeId parameter is already fully documented in the schema. The description adds only the 'by ID' framing, which matches rather than extends the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Get a single time-tracking record') and scopes it to 'by ID', which implicitly distinguishes it from the list_employee_times sibling. It does not explicitly name the alternative, so it stops short of full disambiguation.

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 'by ID' phrasing implies retrieval of a known record, which is a usable usage signal. However, no explicit when-to-use guidance, prerequisites, or named alternatives (e.g. list_employee_times for browsing) are provided.

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

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

No annotations are provided, so the description carries the behavioral burden. It usefully discloses the surprising scope: despite the expenses name, it serves any account and covers income/group-7 accounts omitted by list_expenses_accounts. However, it does not describe return shape, error behavior, auth requirements, or rate limits.

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

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

Two compact sentences, front-loaded with the core action and followed by the important scope caveat. Every sentence adds useful information with no 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-parameter lookup with no output schema, the description gives enough context to call it correctly, including its unusual account coverage and the id requirement. It could mention the returned account object or invalid-id behavior, but the key selection context is present.

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

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

Schema coverage is 100% and the single accountId parameter is already well documented in the schema, including the distinction between Holded id and PGC accountNum. The description reinforces that this is a Holded id but adds no syntax or format details beyond the schema.

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

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

The description uses a specific verb and resource ('Get a single account') and explicitly distinguishes this tool from the sibling list_expenses_accounts by noting it serves ANY account, including income/group-7 accounts that the list endpoint omits. An agent can select it correctly when it already has an id.

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

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

It states the key usage condition ('when you already know its id') and names list_expenses_accounts as the contrasting alternative for listing. It does not explicitly say to use the list tool when the id is unknown, but the contrast is clear enough.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses only that this is a lookup. It says nothing about read-only semantics, permission/auth needs, behavior on a nonexistent ID (e.g., 404 vs empty), or what the response contains.

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

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

One compact sentence with the key qualifier ('by ID') front-loaded and no filler; the API version tag is minor but arguably useful provenance. Slightly terse for a tool lacking annotations, but nothing is wasted.

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

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

For a one-parameter, non-nested getter this is close to adequate, but with no output schema and no annotations, the description leaves the return shape and failure behavior undocumented. A sentence on what the forecast object contains or what happens for invalid IDs would close the 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 baseline is 3. The description's 'by ID' merely restates forecastId's meaning and adds no format, sourcing, or example detail 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 (Get) and resource (cashflow invoicing forecast) plus the lookup key (by ID), which cleanly separates it from list_invoicing_forecasts and the create/update/delete siblings. It stops short of naming that sibling, so it is clear but not fully differentiated in-text.

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

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

'by ID' implies this is for fetching a single known forecast, with listing delegated elsewhere, but no explicit when-to-use or when-not guidance is given. An agent can infer the usage from the sibling set but must do the inference itself.

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

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

No annotations are provided, yet the description discloses two non-obvious behaviors: responses are snake_case and monetary amounts are strings with decimal comma. It does not cover auth requirements, error modes, or default page size behavior, which leaves some of the burden unmet.

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

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

Three compact sentences, front-loaded with the purpose, then pagination, then response-format notes. Minor redundancy with the schema around cursor, but no wasted prose.

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 read-only list tool with a fully documented 5-parameter schema and no output schema; the description compensates for the missing return schema by flagging field naming and amount formatting. Only failure and permission behaviors are left unspecified.

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

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

Schema description coverage is 100%, so all five parameters are already documented. The sentence about passing nextCursor as cursor echoes the schema's cursor description rather than adding format or edge-case 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 (List) and resource (numbering series) plus the scoping key (document type). Against siblings create_numbering_serie / update_numbering_serie / delete_numbering_serie, 'List' makes the read-vs-mutate distinction immediate.

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?

Explains pagination mechanics (pass previous nextCursor as cursor) but never says when to reach for this tool over the sibling numbering-serie tools or any alternative listing path. Usage is implied by the verb rather than stated.

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

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

No annotations exist, so the description carries the full burden. The verb 'Get' reasonably signals a non-mutating single-record fetch, but nothing states behavior on a missing/invalid ID, whether lookup is case-sensitive, or what the response contains.

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

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

One short sentence, front-loaded with the verb and resource, with no redundant text. The parenthetical API version is the only extra and is cheap.

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

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

For a simple one-parameter getter the description is adequate, but with no annotations and no output schema it never indicates what a payment record contains or how failures appear, leaving the agent to infer return behavior.

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

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

Schema coverage is 100% with a single required paymentId, so the schema already documents the parameter. The description only restates that the ID identifies the payment and adds no format or source hints (e.g., where payment IDs come 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 ('a specific payment') plus the key selector ('by ID'), so its purpose is unambiguous. It does not explicitly contrast with near siblings like list_payments or get_document_payments, which keeps it 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 phrase 'by ID' implies the prerequisite (a known payment ID) and implies the split from list_payments, but there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives such as get_document_payments for document-scoped payments.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no return shape, no not-found/error behavior for an invalid ID, no permission or rate-limit context. "(Holded API v2)" adds only a versioning hint.

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 padding. It is efficient, though the terseness borders on under-specification rather than deliberate 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 single-parameter read with full schema coverage and no output schema, the definition is minimally viable. Missing is anything about what a successful response contains or how a bad ID is reported, which an agent calling blind would want.

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 single parameter is structurally documented, and the description merely restates that lookup is by ID. The schema's own description ("Product ID") is tautological, so neither source clarifies format (numeric vs. string, ID source); 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 ("product") scoped to a single record by ID, which implicitly separates it from list_products. It does not name any sibling explicitly, so an agent must infer the list-vs-get split, but the core purpose is unmistakable.

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?

"By ID" implies the precondition (a known productId) and implies list_products is the path for discovery, but neither the alternative nor any exclusion is stated. Usage is inferable rather than guided.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing beyond the one-line purpose. It doesn't say what is returned (URL, binary, metadata), what happens when a product has no main image, or what error surfaces for an invalid productId.

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 parenthetical API version is minor but harmless vendor 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?

The tool is simple, but with no annotations and no output schema, the description should explain the return shape and the empty-image case. Neither is covered, leaving a real gap for an agent that must consume the result.

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 the schema already documents it at 100% coverage as "Product ID". The description adds no format or sourcing 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 and resource: retrieve the *main* image of a product. The qualifier "main" implicitly separates it from the sibling get_product_secondary_image and list_product_images, though it never names 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?

There is no explicit when-to-use, when-not-to-use, or alternative routing. An agent must infer from the word "main" that get_product_secondary_image and list_product_images cover the other cases.

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

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

No annotations are provided, so the description carries the full behavioral burden, but it only states that an image is retrieved. It does not describe return format, image data vs URL, permissions, error behavior, or other retrieval traits.

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 phrase with essentially no wasted text. The parenthetical API version adds minor context but is not essential for tool selection.

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

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

For a simple two-parameter retrieval tool with full schema coverage, the description is adequate for invocation. However, with no output schema and no annotations, it still leaves return-format expectations and sibling selection guidance incomplete.

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 100% description coverage for both required parameters, so the schema already explains productId and imageId. The description adds no additional parameter meaning beyond what the schema provides, 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?

The description gives a specific verb and resource: 'Get a secondary image of a product'. The word 'secondary' distinguishes it from siblings such as get_product_main_image and list_product_images without needing to open the schema.

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

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

It does not say when to use this tool versus get_product_main_image or list_product_images, nor does it provide exclusions or prerequisites. Usage is only implied by the verb 'Get'.

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

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

No annotations are provided, so the description must carry the behavioral burden. It does disclose 'Read-only,' which usefully signals no side effects, but it says nothing about error behavior when an ID is missing or what the returned entry 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 compact sentence that front-loads the core action and scope with zero filler. Every clause earns its place.

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

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

For a simple two-parameter, fully-documented getter with no output schema, the description gives enough to call it correctly and states its read-only nature. Only the return shape and not-found behavior are left unspecified, which is minor here.

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 in the schema. The description restates the parameter intent (project ID, time-tracking ID) but adds no format or syntax detail beyond what the schema already provides.

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

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

The description names a specific verb (Get) and resource (a single time-tracking entry) scoped to project and time-tracking IDs, making it clearly distinguishable from the sibling list_project_times. The word 'single' effectively separates it from list-style operations.

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

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

Usage is implied by 'single ... by project ID and time-tracking ID' — retrieve one known entry. However, it never explicitly states when to use this versus list_project_times or list_project_times_by_project, leaving the agent to infer the choice.

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