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

With no annotations provided, the description carries the full burden of disclosing behavior. It is transparent about what the tool returns: watches meeting the stated price-drop criteria, along with change percentage and reading confidence. It does not mention data freshness or whether it triggers refreshes, but for a list-like read operation this is reasonably 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?

A single sentence packs the purpose, the triggering question, the two inclusion criteria, and the key output fields without any filler. It is front-loaded with the user intent and stays tightly scoped.

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

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

For a zero-parameter tool, the description is sufficient to call it and understand the return value's key fields. It leaves minor ambiguity around terms like 'target' and 'previous observation', but the overall behavior is clear and no output schema exists to compensate.

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

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

The tool has zero parameters, so the input schema is empty and 100% covered. The description does not need to document parameter semantics. Baseline 4 applies because there is nothing missing for an 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?

The description states a specific action ('lists every watch') and defines the exact conditions for inclusion (price at/below target, or ≥5% drop). It clearly differentiates itself from siblings like watch_list (all watches) and price_check (single current price) by focusing on pending discount alerts.

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 opening phrase 'Answer "did anything I watch get cheaper?"' gives a clear trigger for when to use this tool. It does not explicitly exclude alternatives such as price_check or watch_list, but the use case is implied well enough for an agent to select it correctly.

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. It does explain what the tool returns: the business-day count, calendar total, and weekend/holiday counts, which gives a useful model of behavior. However, it does not explicitly state the important limitation that there is no built-in national holiday calendar and that holidays must be passed by the caller; that information exists in the schema instead.

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

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

The description is two sentences with no wasted words. It front-loads the core purpose, then immediately states the return values, which is exactly the information an agent needs to invoke and interpret the tool correctly.

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 calculation tool with four documented parameters and no output schema, the description is nearly complete: it states the operation, use context, and returned components. The only minor gap is that the description leaves the holiday-calendar limitation implicit, but the schema explicitly covers it, so the agent can still call the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters in detail. The description adds use-case context and return semantics but does not provide meaning beyond the schema for individual parameters. A baseline of 3 is therefore 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 action and resource: 'Count the business days between two dates in a place.' It also names concrete use cases ('delivery dates and payment terms') and the output components, making the tool's purpose unambiguous. No sibling tool overlaps, so further differentiation is unnecessary.

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 clear context for when to use the tool: counting business days in a place, especially for delivery dates and payment terms. It does not explicitly name alternatives or exclusions, but no sibling tool appears to offer the same calculation, so the context is sufficient for an agent to select it.

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 disclosure burden. It transparently indicates a read-only status operation scoped to the local machine, and it sets expectations about the kind of information returned (cached items, age, refresh time). It does not explicitly state that the operation has no side effects, but 'status' implies a non-mutating check.

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

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

The description is two concise sentences with no filler. The first sentence front-loads the core output fields, and the second sentence adds an important usage caution. Every word 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 zero-parameter status tool with no output schema, the description fully covers what the agent needs: what the tool reports, its local/offline context, and when to consult it. Nothing critical is missing for correct invocation.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The description sufficiently substitutes for an empty schema by describing what the tool reports, and the baseline for zero-parameter tools is 4.

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

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

The description clearly specifies that the tool reports what is cached, how old the cache is, and when it will refresh. This differentiates it from sibling rate/value tools by focusing on cache state rather than rate data itself, though it lacks an explicit verb like 'returns' or 'shows'.

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 a clear context for use: check this before trusting a rate on a machine that has been offline. It does not discuss when not to use it or name alternative tools, but the provided guidance is actionable and specific.

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

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

No annotations are provided, so the description carries the behavior disclosure burden. It is transparent about the operation's scope ('Every calendar imported into this server') and the exact data fields returned, which effectively communicates a read-only listing behavior. It does not spell out side effects or failure modes, but the verb 'List' and the descriptive sentence make the non-destructive nature evident.

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

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

The description is a single concise sentence that front-loads the subject and scope, then lists the returned attributes. There is no redundancy, filler, or unnecessary detail; every part of the sentence contributes to the agent's understanding.

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

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

For a zero-parameter, no-output-schema list tool, the description covers the essential information needed to call it: what is listed, the scope, and the fields in the result. It does not mention ordering, pagination, or empty-result behavior, but those are minor for this simple metadata-listing tool and are not required by the input schema or 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?

The tool has zero parameters, so there is no parameter-semantics burden on the description. The schema is fully coverage because there is no schema to explain. This meets the baseline 4 for a no-parameter tool.

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 title 'List imported calendars' states a specific verb and resource, and the description expands on it: it enumerates exactly what will be returned—name, source, event definition count, and import date. This clearly distinguishes it from sibling tools like schedule_list or events_list, which concern schedules and events rather than calendar import metadata.

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

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

The description implies usage: use this tool to inspect imported calendars on the server. However, it provides no explicit guidance about when to prefer it over alternatives, and it does not excludeevent or schedule listing tools. For a simple zero-parameter list tool this is acceptable, but not fully explicit.

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

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

There are no annotations, so the description carries the behavioral burden. It discloses the primary side effect ('Save'), and explicitly states what the operation returns: stored clause id, title, category, tags, detected variables, and the updated count of owned clauses. This gives the agent a concrete model of the operation's effect, though it does not cover duplicate handling, permissions, or failure modes.

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 that states the action first and then the return value. Every phrase contributes useful information, and there is no filler, repetition, or unnecessary background.

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

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

With no output schema, the description provides a helpful list of return fields and gives the agent a clear sense of the operation's outcome. The input schema covers parameter details thoroughly. It is not fully complete because it omits the output format and any caveats about limits or duplicate titles, but those are not critical for selecting and invoking the tool correctly.

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

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

Schema description coverage is 86%, so the structured schema already documents most parameters well. The description adds only a small amount of parameter-related meaning by mentioning that variables are 'detected in its body,' which relates to the body placeholder behavior already covered in the schema. No further compensation is required.

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

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

The description uses a specific verb and resource: 'Save a reusable contract or proposal clause to the library.' This clearly indicates a creation/persistence operation and makes the tool understandable next to siblings like clause_update, clause_delete, and clause_get. However, it does not explicitly distinguish itself from clause_import or other similarly named 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?

The description implies this tool is for adding a new clause to the library, which is clear context for creation. It does not explicitly state when to prefer this over clause_update, clause_import, or contract_assemble, nor does it mention any exclusions or alternatives.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses one valuable non-obvious trait — 'A deleted starter clause is not re-seeded on the next call' — which tells the agent the deletion is persistent even for starter clauses. However, for a destructive operation it does not disclose cascading effects on contracts assembled from the clause, idempotence when the id does not exist, or reversibility, leaving significant behavioral gaps.

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

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

Two sentences, each earning its place: the first states the primary action, the second adds a crucial behavioral caveat about starter clauses. The main action is front-loaded and there is no filler or redundant restating of the title.

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

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

For a simple tool — one required parameter, full schema coverage, no output schema — the description covers purpose and the key persistence behavior. Minor gaps remain: behavior when the id or title does not match any clause, and whether deleting a clause impacts contracts that reference it. These are moderate but not blocking for a single-parameter delete operation.

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

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

Schema description coverage is 100% — the 'id' parameter is documented as 'Clause id or exact title' — so the baseline of 3 applies. The description adds no parameter-level detail, such as how to resolve an exact title or what happens when the id is not found. The schema carries the full weight, and the description does not compensate beyond it.

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: 'Remove a clause from the library.' This clearly distinguishes the tool from its siblings — clause_add, clause_get, clause_update, clause_list, clause_search — which perform different operations. The title and description align, so an agent can identify the tool's purpose without opening the schema.

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

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

Usage is implied by the verb: an agent can infer this tool is for removing a clause. However, the description gives no explicit when-to-use or when-not-to-use guidance, and does not mention alternatives such as clause_update for editing instead of deleting or clause_search for locating the clause first. The re-seeding caveat is more behavioral context 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?

With no annotations provided, the description carries the full burden and does a good job: it discloses the side effect (writing the library to a file) and the return contract (path, format, clause count). It could also mention failure behavior or explicitly state that the source library is not modified, but the core behavioral contract is well covered.

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

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

The description is two sentences with no wasted words. The action and scope are front-loaded, and the second sentence gives a compact list of return values. Every sentence earns its place.

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

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

For a relatively simple export tool with 3 parameters, no output schema, and a clear schema, the description plus schema provides enough context for correct invocation: destination path, required format, overwrite behavior, return values, and scope. It doesn't discuss error cases or the Pro-vs-free behavior beyond what the schema notes, but those are secondary for a straightforward export.

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 per cent, and each parameter already has a meaningful description. The tool description adds no additional parameter-level semantics; it only reinforces the overall scope. A baseline score of 3 is appropriate when the schema carries the parameter-documentation load.

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

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

The description uses a specific verb ('write'), names the resource ('the whole clause library'), and states the output ('one file'), which clearly differentiates it from per-clause operations like clause_get, clause_add, and clause_import. The scope qualifier 'whole' removes ambiguity about partial exports.

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 opens with 'Call this tool to...' and defines the intended use case for exporting the full clause library. It doesn't name alternatives or state when not to use it, but the use case is clear enough that an agent would not confuse it with the many unrelated sibling tools.

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

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

No annotations are present, so the description carries the full burden. It mentions the 'Pro' revision-count behavior but omits error handling, precedence rules, or any side effects.

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

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

A single sentence that is compact and directly states the action, target, and notable output detail.

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

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

Describes the return value but leaves gaps around parameter requirements, not-found behavior, and interaction between id and title. Adequate for a simple read but not fully complete.

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

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

Schema covers both parameters with short descriptions; the tool description repeats them but adds little beyond the schema, so it meets the baseline for high 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?

States a specific verb ('Return') and resource ('a clause in full'), with details about variables and revision count that distinguish it from list/search 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?

Clearly indicates retrieval by id or title, but does not explicitly mention when to prefer list/search alternatives or what happens if both parameters are omitted.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that imports can be added or replaced, that some may be skipped or blocked by the free clause cap, and it describes the exact return information (counts plus new library total). This gives the agent meaningful awareness of side effects and outcomes beyond a simple one-line summary.

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

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

Two sentences with no wasted words. The first sentence states the purpose and scope; the second sentence describes the return value. The most important behavioral outcome, bulk-loading from file, is front-loaded.

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's purpose, source format, overwrite option, and return metrics are all covered either in the description or the parameter descriptions. Since there is no output schema, the description appropriately discloses the return payload. No critical missing information prevents an agent from calling it correctly.

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

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

Schema description coverage is 100%, and both node parameters are already thoroughly documented in the schema. The description adds no additional parameter semantics because the schema already explains path formats, JSON Pro restriction, overwrite behavior, and the free clause cap. 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 uses a specific verb ('bulk-load') with a clear resource ('clauses into the library') and source ('markdown or JSON file'). This clearly distinguishes it from single-clause tools like clause_add and export tools like clause_export.

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 opening phrase 'Call this tool to bulk-load' clearly identifies the intended use case. It signals that this is for batch importing rather than individual clause operations, and the sibling list reinforces the contrast with clause_add. It does not explicitly exclude alternatives, but the intended scenario is clear.

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 behavioral disclosure. It does state ordering ('newest categories first') and the read-only nature implied by 'List', but the ordering phrase is ambiguous and pagination, return format, or potential limits are not disclosed. It adds some behavior context but not full clarity.

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

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

The description is a single sentence with no filler and the core action is front-loaded. The phrase 'newest categories first' is somewhat awkward but the description remains appropriately compact.

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 list tool, the description covers the core scope and filtering behavior. However, the ambiguous ordering phrase and complete lack of output/return details, especially with no output schema or annotations, leave a meaningful gap for an agent trying to reliably use 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?

The schema has one undocumented 'category' string with 0% description coverage. The description compensates by explaining that the list can be 'narrowed to one category,' giving the parameter a clear role. It does not enumerate valid values or format, but for a simple optional filter this is sufficient.

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 uses a specific verb and object: 'List every clause.' It also states the optional category filter, which clearly distinguishes this broad listing tool from focused retrieval tools like clause_get or clause_search. The resource and scope are immediately understandable.

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

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

The description implies usage: use this to list all clauses, optionally filtered by category. However, it does not explicitly contrast with clause_search or clause_get, and provides no when-not-to-use guidance. Context is present but exclusions and alternatives are left to inference.

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

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

With no annotations, the description carries the burden and does meaningful work: it discloses ranking precedence, the Pro-only tag filter behavior, and the fallback of skipping rather than refusing. It does not cover output shape or authorization requirements, but the core non-obvious call behavior is surfaced.

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 tight sentences with no filler. The most decision-relevant information (ranked scope, ranking priority, and free/Pro behavior) is front-loaded and each sentence earns its place.

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

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

For a simple search tool, this is largely complete: it identifies the searchable resource, the ranking behavior, and the filter constraints. The main remaining gap is that the category parameter has no schema description and is only indirectly covered by the phrase 'categories', but this does not prevent a competent agent from invoking the tool 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?

The schema already describes query, tags, and jurisdiction, so the description adds limited parameter-level meaning. It does clarify category's role by mentioning categories as a search target, and it reinforces the tag-skipping behavior, but it does not substantially go 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 and object: 'ranked search over clause titles, tags, categories and bodies'. The ranking detail further distinguishes it from a plain list (clause_list) and from other clause 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?

The description implies this is the right tool when ranked keyword search over clauses is needed, and it explains filter availability. However, it does not explicitly say when to prefer clause_list or other clause tools instead, so usage guidance is mostly implied rather than explicit.

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

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

With no annotations, the description carries the responsibility of disclosing behavior, and it does add important context: Pro keeps a version of the previous text while the free tier overwrites without history. This is a meaningful behavioral caveat beyond the schema. It does not cover return values or permission requirements, but the key side-effect is stated.

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

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

Two concise sentences with no wasted words: the first states the operation and its targets, the second adds the critical versioning caveat. The information is front-loaded and easy to parse.

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 includes the core purpose and a notable behavioral distinction, but it leaves gaps around the full set of mutable fields and the actual meaning of 'text' versus 'body'. With no output schema and no annotations, an agent may not know what response to expect or how to set fields like language or title. This is a moderate gap rather than a severe one.

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

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

Schema description coverage is only 13% (only 'id' is described), so the description must compensate. It lists several updatable fields but uses 'text' where the schema property is 'body' and omits 'title' and 'language', leaving the parameter mapping ambiguous and incomplete. This is insufficient for an agent to confidently construct a full update request.

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 ('Change') and resource ('clause'), and it names several mutable fields, which clearly conveys the update intent and distinguishes it from sibling tools like clause_add or clause_delete. However, it omits 'title' and 'language' from the field list, so its differentiation is slightly incomplete.

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 wording implies updating an existing clause rather than creating or deleting one, but there is no explicit statement of when to prefer this tool or avoid alternatives. With many sibling tools in the same domain, an agent has to infer the usage context from the action verb and field list.

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 discloses two important behaviors: re-adding the same name updates stored details, and an identical record is refused with the id of the existing record. This gives useful idempotency and duplicate-handling context, but it omits return value, permission requirements, and whether other fields are cleared when updating.

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

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

Two sentences with no fluff. The core purpose is front-loaded, and the behavioral nuance about update/duplicate refusal follows naturally. It is appropriately concise for a CRUD 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 tool with no output schema, no annotations, and only 25% parameter coverage, the description is incomplete. It doesn't explain the response structure (e.g., the returned id), how updates affect unspecified fields, or any required permissions. An agent would need to make assumptions or call the tool to learn more.

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 only 25% (vat_id has a description). The description adds meaning for the 'name' parameter as the matching key for updates and duplicate detection, but it doesn't explain email, address, or vat_id beyond what the schema provides. Given the low coverage, the description should compensate more than it does.

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

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

The description clearly states the verb 'Store a client' and the purpose 'so invoices can refer to them by name.' It is specific to client_add and distinguishes its upsert behavior from a plain create, though it doesn't explicitly contrast with sibling tools like client_delete or client_list.

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 given on when to use this tool versus alternatives. It doesn't mention client_list for viewing, client_delete for removal, or any prerequisite context. The agent must infer usage from the description 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 of behavioral disclosure. It clearly reveals that deletion is conditional and that the tool names any referencing document when refusing deletion. It is not annotated as destructive, but the word 'Delete' inherently signals destruction, and the description adds non-obvious dependency 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?

Two succinct sentences with no filler. The first sentence states the action and precondition, the second details the refusal behavior with a specific list of document types. Front-loaded and easy to parse.

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 tool with no output schema, the description covers the main behavior, the dependency restriction, and the error response style. A minor gap is that it does not state success response behavior, but the core information needed to select and invoke the tool correctly 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?

The input schema already fully documents the only parameter with the note 'Client name or id, exactly as client_list shows it.' The description adds no additional parameter-level meaning, so the baseline of 3 applies because the schema is doing the heavy lifting.

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

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

The description states a specific action and resource: delete a stored client, and clarifies the key condition that it must be unused. This clearly distinguishes it from sibling tools like client_add and client_list, and the title 'Delete a client' is reinforced rather than merely restated.

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 clear context: use this when you want to delete a client that has no references, and it warns that referenced clients will be refused. It does not name an alternative tool, but no close alternative for deletion exists among siblings, so the guidance is adequate.

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

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

Since no annotations are provided, the description carries the burden of behavioral disclosure. It states that the operation is non-mutating (list), has no filtering ('every stored client'), and reveals the returned fields. It does not mention pagination, sorting, or authorization, but for a simple zero-parameter read-only tool this is sufficient 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?

The description is a single, efficient sentence with no redundant wording. It front-loads the core action and scope, then lists the relevant output fields, so every word 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 zero-parameter tool with no output schema and no annotations, the description is complete enough for an agent to invoke it correctly. It clearly states the scope ('every stored client') and the fields that will be returned, leaving no significant gap.

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

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

The input schema has zero parameters, so there is no parameter information that the description needs to enrich. The baseline of 4 applies because no parameter semantics are missing.

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

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

The description names a specific action and resource ('List every stored client') and specifies the returned fields (id, address, email, VAT id), so it is clear and not a tautology. It does not explicitly name or distinguish itself from sibling list tools such as contacts_list, so it falls short of full differentiation.

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

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

No explicit guidance is given about when to use this tool versus alternatives, and no sibling tool is referenced. The intended usage is only implied by the action 'List' and the resource 'every stored client'.

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 transparency burden. It discloses the core behavioral traits: returns all overlapping pairs, includes collision minutes, handles whole-day events separately, and enforces a plan-based date window. It could add output structure details, but it covers the most important behaviors for correct invocation.

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 tightly written sentences lead with the primary semantic, then add scope, special cases, and plan limits. Every sentence provides actionable 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 read-only detection tool with three parameters and no output schema, the description gives enough behavioral and contextual information to select it and call it correctly. It leaves some return-format details unspecified, but the core semantics are covered.

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. Descriptions of from, to, and calendar already exist in the schema; the tool description mostly repeats the calendar default and adds a plan limit, but adds little per-parameter meaning 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?

The description clearly defines the tool as finding every pair of overlapping events and reporting the collision minutes. It also notes that it spans all calendars by default unless one is named, which sharply distinguishes it from single-calendar event tools like events_list or free_busy.

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 concrete context for when to use the tool: when cross-calendar clashes matter, and it explains the optional calendar parameter behavior. It does not explicitly name alternatives or say when not to use it, but the use case is strongly implied.

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 present, the description carries the burden of conveying side effects. Listing saved contacts is clearly a read-only operation, and the description adds useful context about computed fields (current local time and working-hours status), though it does not explicitly state that no data is modified.

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

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

The description is a single, concise sentence that conveys the core function and the extra computed information. There is no redundancy or unnecessary detail.

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

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

For a simple parameterless list tool, the description provides sufficient context: it names the resource, the scope ('everyone you have saved'), and the enriching fields (local time and working-hours status). It could be slightly more explicit about the output shape, but that is not critical for such a simple tool.

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

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

The tool has zero parameters, so there are no parameter details to document. The baseline for no parameters is 4, and the description appropriately focuses on the output and behavior rather than input fields.

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

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

The description clearly states that the tool returns all saved contacts along with their current local time and working-hours status. The title reinforces the resource (saved contacts) and the action (list), distinguishing it from the related contacts_set tool.

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

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

The intended use is implied by the title and description: use this when you need to see saved contacts and their time/working-hours info. However, it does not explicitly contrast with alternatives like contacts_set or mention conditions when this tool should be preferred.

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, but it only says 'Remember' and describes the future benefit. It does not state whether an existing contact with the same name is upserted, whether a new contact is always created, or what the tool returns/side effects are.

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

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

Single-sentence, front-loaded with the core action and resource, and uses an illustrative example instead of restating schema. The phrase 'later' appears once in the main clause and once in the example, a tiny redundancy.

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

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

For a simple set operation, the schema plus description cover required inputs and the purpose. The main missing context is mutational behavior (create vs update) and success/failure output, which no annotation or output schema helps fill.

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?

All four parameters are documented in the schema (100% coverage), so the description does not need to repeat details. It adds only the high-level 'time zone and working hours' framing and the scheduling use case, which is sufficient but minimal.

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

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

The description uses a clear verb ('Remember') and identifies the resource ('a client or teammate's time zone and working hours'), then ties it to a concrete downstream use case. It does not explicitly contrast with contacts_list or explain whether setting overwrites, but the purpose is unambiguous.

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

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

The description implies when to use the tool – when you want to store a person's zone and hours for later scheduling. It provides no exclusions or comparison with sibling tools such as contacts_list or find_meeting_slots, so an agent must infer the exact boundary.

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 behavioral disclosure burden, and it delivers a clear return contract: path written, clauses in document order, filled variables, and missing facts left as bracketed prompts. This complements the schema's 'never as an invented value' guarantee. It does not explicitly flag the file-writing side effect or overwrite behavior, though those are well documented in the overwrite parameter's schema description.

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 waste: the first front-loads the action verb and resource, the second packs return-value details into a single dense clause. Every phrase ('path written', 'document order', 'filled variables', 'bracketed prompts'') conveys information not present elsewhere in prepared form.

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

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

For a tool with 8 parameters, a nested values object, no output schema, and no annotations, the combination of an exhaustively documented schema and a description that covers return semantics is fairly complete. The remaining gaps are tool-selection guidance against sibling creation tools and a top-level side-effect statement, but the agent can correctly invoke this tool from what is provided.

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 even though the description adds no new parameter-level meaning. The return-value sentence does reinforce the semantics of clause_ids (document order) and values (missing facts stay as bracketed prompts), but the schema already explains every parameter in detail. No uplift above baseline is earned.

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 ('build'), a clear resource ('contract or proposal document'), and the mechanism ('from library clauses'), which separates it from siblings like contract_create and proposal_create. The scope is explicit and an agent can tell this assembly tool apart from the clause-library management tools 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?

The phrase 'build a contract or proposal document from library clauses' implies the use case: assembling documents from an existing clause library. However, the description gives no explicit when-not-to-use guidance and never names the overlapping siblings (contract_create, proposal_create, doc_fill_template), so routing between those alternatives is left to inference.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses that the output is a template skeleton for lawyer review, explicitly states it is not legal advice, and mentions the free tier limit of 3 agreements per month. It does not detail file overwrite behavior, but the schema already covers that through the overwrite parameter.

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

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

Three concise sentences with a clear front-loaded action, followed by return value note, legal disclaimer, and usage limit. Every sentence contributes information without repetition or 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?

The description covers the key non-schema information an agent needs: what is produced, what is returned, the legal nature of the output, and a usage restriction. Since there is no output schema, the minimal return-value disclosure is helpful, though it could be more explicit about error cases or quota enforcement details.

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

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

Schema description coverage is 89%, so the input schema already documents most parameters in detail. The description adds little beyond mentioning that the fee and file path are returned, which does not directly clarify parameter semantics. It neither compensates for undocumented parameters nor adds meaningful input guidance beyond the schema.

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

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

The description states a specific action ('produce') and resource ('freelance service agreement .docx'), making the core purpose clear. It does not explicitly distinguish itself from related sibling tools like contract_assemble or proposal_create, but the type of document is specific enough to guide selection.

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

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

It gives a direct imperative ('Call this tool to produce...'), which clearly indicates the intended use case. However, it does not mention alternatives or when not to use it, and with siblings like contract_assemble nearby, the lack of routing guidance leaves some ambiguity.

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 it delivers: it discloses the converted amount, the cross rate to 6 decimals, the rounding applied, and the rate date used. The parameter descriptions further reveal important behaviors like default-to-currency, minor-unit rounding, weekend/holiday fallback, and the 90-day window fallback. This gives an agent a reliable picture of the tool's behavior, including edge cases.

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 tightly written sentences: the first front-loads the call action and scope, the second compactly enumerates the return contract. Every clause adds value, and the parameter descriptions are detailed without being bloated.

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

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

There is no output schema, but the description compensates by listing the returned fields: converted amount, cross rate to 6 decimals, rounding applied, and rate date used. Combined with complete parameter documentation and fallback behaviors, an agent has enough information to invoke the tool 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?

The input schema has 100% coverage, with rich descriptions for all four parameters including defaults, rounding behavior, date fallback, and the euro cross-rate path. The main description adds high-level context but does not need to restate parameter details; the schema already does the heavy lifting.

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

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

The description states a specific operation ('convert an amount') with a clear resource scope: any two ECB-quoted currencies, today or on a past date. It is easily distinguished from sibling tools like convert_time or currency-rate lookups because it focuses on a single conversion and its output contract. The title and description reinforce each other without ambiguity.

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

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

The opening phrase 'Call this tool to convert an amount' gives a direct, actionable usage instruction, and the scope (single amount, ECB currencies, date choice) defines the context clearly. It does not explicitly name alternatives such as convert_many or fx_rates_for, so it stops short of a full 5, but the guidance is well implied.

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 adds meaningful behavioral details beyond the schema: all conversions share the same ECB rate date, and each result is rounded to its target currency's minor units. It does not describe the response shape, but the described behavior is clear and non-contradictory.

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

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

Two concise sentences deliver the core behavior without wasted words. The key constraint (one source, many targets, same rate date) is front-loaded, and the rounding detail adds value without bloating the description.

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

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

The description covers input semantics and key behavior, but there is no output schema and no explanation of what the result format looks like. An agent can invoke the tool reasonably well, but it cannot predict whether the response is an array, a map keyed by currency, or something else.

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

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

Schema description coverage is only 33%, so the description must compensate. It maps 'amount' to the single input amount, 'from' to the source currency, and 'to' to the many target currencies. This gives the agent the parameter roles even though the schema only documents 'to' with a brief description.

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 ('Convert') with a precise resource scope: one amount, one source currency, many target currencies, all using the same ECB rate date. The 'many targets' qualifier clearly distinguishes this tool from the sibling 'convert' and other rate-related 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?

The description clearly implies the intended use case: converting one amount into multiple currencies at once. It does not explicitly name alternatives or state when not to use the tool, but the 'one source, many targets' framing gives an agent enough context to select it over the singular 'convert' sibling.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add genuine value: the wall-clock interpretation rule, the offset/trailing-Z exception, and the natural-language input support. However, it omits the output format and error/edge-case behavior (though the gap/fold enums are already documented in the schema), so coverage is partial rather than 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?

Three sentences with zero waste. The primary action is front-loaded in the first sentence, the interpretation rule follows, and the accepted formats close it out. Every sentence earns its place with distinct 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?

Input handling is well covered (parsing rules, accepted formats, zone interpretation), and the gap/fold DST edge cases are documented in the schema. But with no output schema and no annotations, the description should have disclosed what the response looks like or how results are shaped; its omission leaves an agent to invoke the tool without knowing what to expect back. Moderate complexity (4 optional edge-case params) was not fully exploited.

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, but the description adds real meaning beyond the schema: it explains that 'time' is read as wall-clock in from_zone unless it carries an offset or trailing Z, enumerates accepted formats (datetime string, ISO, '3pm tomorrow'), and clarifies that multiple target zones are expected. This materially helps an agent construct valid inputs.

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 ('Convert'), resource (time), and scope ('from one place to others'), making the core function clear. The parsing rules and accepted input formats add further specificity. However, it does not differentiate itself from sibling tools like 'convert' or 'convert_many', which could plausibly do the same job.

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 given on when to use this tool versus the several time-related siblings ('now', 'convert', 'convert_many', 'dst_changes', 'business_days'). There is no mention of exclusions, prerequisites, or conditions that would select this tool over an alternative.

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?

There are no annotations, so the description carries the burden of explaining behavior. It discloses that the tool writes a cover letter, uses the stored profile, and returns the output path, word count, and unresolved bracketed prompts. It does not mention overwrite/failure behavior or the need for a pre-existing profile, but the write action 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 two concise, front-loaded sentences. It states the action and scope immediately, then adds valuable return-value context. There is no filler or redundant rewording of the schema.

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

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

For an 8-parameter tool with no annotations and no output schema, the description covers core returns and document scope, but omits required parameters, preconditions, overwrite semantics, and how to choose this over resume_create/proposal_create. It is minimally viable but has clear gaps.

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

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

Schema description coverage is only 63%, and the description adds little per-parameter meaning. The 'bracketed prompt' phrase echoes what the highlights schema already says; parameters like role, company, and hiring_manager remain undocumented in both the schema and description.

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 ('write'), a specific resource ('one-page cover letter'), and a clear source ('from the stored profile'). It also gives the document structure ('opening, fit, proof, close'), which distinguishes it from sibling tools like resume_create or proposal_create.

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

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

The description explicitly tells the agent when to use it: when a one-page cover letter should be written from the stored profile. It does not name alternatives or exclusions, but the intended trigger is clear enough for an agent to select it appropriately.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly discloses the data source (ECB daily reference set), the fields returned (rate against euro and decimal places), and the scope limitation. While it does not state return formatting or ordering, it provides solid transparency for a simple read-only listing tool.

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

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

The description is compact: two sentences that front-load the core purpose and then add the important constraint about unsupported currencies. Every sentence earns its place and there is no redundant or filler wording.

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

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

For a parameterless listing tool with no output schema, the description gives enough information about the result contents and scope to be usable. A minor gap is that it does not mention how to request specific data or how results are ordered, but those are not critical for this simple tool.

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

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

The tool has zero parameters, so the baseline is 4. The description appropriately focuses on what the tool returns rather than parameter details, since there are none to document.

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

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

The description clearly states that this tool returns every currency in the ECB daily reference set along with its euro rate and decimal places. It also establishes a clear boundary by noting that anything not on the list cannot be converted, which differentiates it from sibling conversion 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?

The description implies the tool should be used to check which currencies are supported for conversion, especially through the sentence 'Anything not on this list cannot be converted here.' However, it does not explicitly say when to use this tool versus sibling tools like rates_latest, convert, or fx_rates_for.

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 only mentions output (file path, block count, layout) and claims 'Free and unlimited'. It does not disclose side effects like file overwriting behavior (default false), the possibility of errors, or what happens if the file exists. This is a transparent 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 brief and front-loads the core purpose. However, the phrase 'Free and unlimited' is extraneous and adds noise without aiding tool selection, preventing a perfect score.

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 moderately complex nested schema (sections with headings, paragraphs, lists, tables), the description is sparse. It does not illustrate the concept of 'structured sections' or how the layout styles (plain, letter, proposal) affect output. While the schema fills many gaps, the description alone is not 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% and every parameter already has a descriptive comment. The tool description adds no additional meaning about parameters beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('write') and resource ('a real .docx file') and clarifies the input format ('structured sections'). It also lists the return values, making the tool's purpose unmistakable. This clearly distinguishes it from siblings like doc_from_markdown or doc_read.

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

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

No explicit guidance is given on when to use this tool versus alternatives such as doc_from_markdown or doc_fill_template. The description does not mention scenarios or conditions that would prefer this tool, leaving the choice 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 burden, and it discloses the key behaviors: writing a new file, returning the new path, and reporting replaced, unfilled, and ignored placeholders. It also adds the non-obvious behavior that calling with no values lists placeholders instead of filling. It could state explicitly that the original template is never modified, but 'write a new file' plus the schema's out_path default make this reasonably clear.

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

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

The description is two sentences with the primary action front-loaded. It includes only essential information: the operation, the return value, and the alternate listing mode. No filler or duplication of schema details.

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

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

With no annotations and no output schema, the description still covers the main call, the return payload, and the no-values listing mode. It relies on the schema for overwrite and out_path details, which is acceptable, and it could add a brief note that the original template itself is not modified, but overall it is complete enough for an agent to select and invoke the tool 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%, so the baseline is 3, but the description adds meaningful value by explaining that omitting values triggers placeholder listing. This clarifies that values is optional and that an empty/absent values object has a distinct, useful behavior. The ignored-status language also helps the agent interpret values that do not match any placeholder.

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 explicitly states the action: replace {{placeholders}} in an existing .docx and write a new file. It also distinguishes the tool from document creation/reading siblings like doc_create, doc_read, and cover_letter_create by focusing on template filling.

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 'Call this tool to replace {{placeholders}}' clearly establishes the primary use case, and the no-values listing mode provides a secondary use. It does not explicitly name sibling alternatives or when-not-to-use conditions, but the intended context is clear.

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 add beyond-schema value: it states the return payload ('a count of the blocks written, by type'), important since no output schea exists, and the policy 'Free and unlimited'. It does not describe failure behavior when a file already exists or conversion errors, though the overwrite default is already captured in the schema.

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

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

Three short sentences with the core purpose front-loaded in the first. The imperative 'Call this tool to' is slightly redundant framing and 'Free and unlimited' is ancillary, but overall the text is compact, scannable and every substantive piece earns its place.

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

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

For a 5-parameter tool with 1 required and no output schema, the description plus schema covers the essentials: purpose, return value, parameter defaults and overwrite policy. It is weak on routing among the many document siblings and silent on error/conflict behavior, but for a simple conversion tool this is adequate rather than deficient.

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 80%, above the high threshold, so the baseline applies. The description adds no parameter-level meaning: the markdown parameter is already extensively documented in the schema and the style enum values are self-seplanatory. The mention of block counts hints at supported constructs but adds nothing beyond the schema's list of headings, lists, tables and code blocks.

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 descrition uses a clear verb+resource framing: 'turn markdown into a .docx', with the title 'Markdown to Word' reinforcing the same conversion. It is unmistakably a markdown-to-docx converter and the direction implicitly sets it apart from siblings like resume_to_markdown and doc_to_html, though it never names them explicitly.

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

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

'Call this tool to turn markdown into a .docx' is an explicit invocation instruction, giving an agent the canonical use case. However, no alternatives or exclusions are provided, which matters here because the sibling list contains plausible adjacent document tools (doc_to_html, doc_create, convert, proposal_create) that an agent might conflate with this one.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the return behavior: outline of headings, full text in document order, or block structure, and notes that usage is free and unlimited. 'Extract' also implies a non-destructive read operation, though it does not explicitly state 'does not modify the file.'

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

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

The description is short, front-loaded with the invocation guidance, and delivers the output behavior in a singlefollow-up sentence. The 'Free and unlimited' note is brief and adds useful operational context without bloating the description.

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 read tool with 100% schema coverage and no output schema, the description provides the essential decision and invocation information: what file type to target, what the tool returns, and the two output flavors. Nothing critical is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents both 'path' and 'format.' The description's mention of outline/headings and block structure loosely maps to the format enum, but it does not add meaningful parameter semantics 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: 'extract the text of an existing .docx.' It clearly differentiates this tool from siblings like doc_to_html, pdf_text, and resume_read by specifying the .docx text-extraction behavior and the outline/block-structure output.

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 opening phrase 'Call this tool to extract the text of an existing .docx' gives explicit guidance on when to use it. It does not name alternative tools or exclusion cases, but the context is clear enough for an agent to select it for reading .docx text.

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 present, so the description carries the burden. It discloses that the tool returns a path, does not render PDF directly, and is 'free and unlimited.' This gives useful behavioral context, though it doesn't cover all edge cases.

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

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

The description is two sentences, concise, and well-structured. It covers purpose, output, and a key usage hint without fluff or redundancy.

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

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

For a simple tool with three well-documented parameters, the description provides enough context: converts docx to semantic HTML, returns path, supports PDF workflow, and is free/unlimited. It lacks an output schema but doesn't need one. Minor gaps like error behavior are not critical.

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 already fully describes all three parameters (path, out_path, overwrite) with clear descriptions. The tool description adds context about the conversion purpose but does not add new meaning to the parameters themselves, matching the baseline for full 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 clearly states the tool converts .docx to semantic HTML, mentions the output is a file path, and highlights its use for printing to PDF. This is specific and distinct from sibling 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?

It explicitly says 'This is the supported PDF route; no PDF is rendered here,' which directs when to use this tool (when HTML is needed for PDF output) and what to avoid (expecting direct PDF). While it doesn't name alternative tools, the condition is clear.

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 vaguely mentions that changes go to a shared profile and affect invoice issuer and default VAT, but it does not clarify persistence, overwrite behavior, validation, or any other meaningful side effects. With no annotations, this is insufficient.

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 short, but the second sentence is confusing and poorly worded, making it less concise and harder to parse than a simple clear statement would be.

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 17 parameters, no output schema, and no examples, the description lacks crucial context such as return behavior, required-field implications, or how the shared profile relationship impacts callers.

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 descriptions for all 17 parameters, including aliases and defaults, so the description itself adds little parameter-level meaning. This meets the baseline but does not exceed it.

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 title 'Set your business details' is clear, and the description indicates it configures sender/profile information shown on documents. However, the body is garbled ('The SAME profile invoice's business_set writes:') and never plainly states that calling this tool updates the business profile.

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 siblings like profile_set or invoice_business_set, nor are any prerequisites or expected call contexts 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 are present, so the description carries the burden of explaining behavior. It discloses the key output traits: exact UTC instant and offsets before/after the change. This is meaningful for an agent. It could say more about empty results or return shape, but for a simple query tool this is reasonably transparent.

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

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

Two concise sentences. The first states the output content, and the second provides a practical use case. Every sentence earns its place, and there is 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 low-complexity, two-parameter tool with no output schema, the description gives enough context: what is returned, the time detail, and the intended use. It could be slightly richer by noting what happens when a zone has no daylight-saving changes, but nothing critical is missing for normal 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?

Schema coverage is 100%, with clear descriptions for year ('Calendar year, default this year') and zone ('Place or IANA zone'). The description adds no extra parameter meaning beyond the schema, 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 clearly identifies what the tool provides: daylight-saving clock changes for a place/year, with UTC instants and before/after offsets. It does not use a strong verb like 'returns' or 'lists', but the resource and output content are specific. It is distinguishable from time-related siblings by focusing on DST transitions.

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 an explicit use case: checking whether a recurring call moves for one participant in March or October. This is practical and helps an agent know when this tool is relevant, though it does not name alternatives or explicitly say when not to use it.

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. It discloses that the tool persists a timesheet entry and only accepts already-worked time, and it hints at rate/currency conversion with the example '90 euros an hour' -> EUR. However, it does not describe what the tool returns, whether it mutates anything besides creating the entry, or what happens when a project name doesn't match.

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-load the purpose and then give the core usage rules without redundant wording. Every sentence adds meaningful information: what the tool does, what inputs are required, and how rate/currency can be expressed.

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 schema documentation covers all 10 parameters in detail, the description doesn't need to repeat them. It provides the essential behavioral model and parameter relationships needed to call the tool correctly. The lack of an output schema is a minor gap, but not critical for a create-style timesheet tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the relationship between start, end, and minutes ('start plus either end or minutes'), and by giving a concrete natural-language rate example ('90 euros an hour' -> EUR) that clarifies how string rates and currencies are meant to be supplied.

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

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

The description names a specific verb and resource: 'Log ... time you already worked on a project - a timesheet entry.' It clearly distinguishes this from live-timer or time-conversion siblings by emphasizing 'already worked,' and the title 'Add time entry' matches the behavior exactly.

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 a clear use case: recording already-completed work as a timesheet entry, which implies it is not for ongoing-time tracking or future scheduling. It also explains the required input pattern: 'start plus either end or minutes.' It does not name alternative tools explicitly, but the context is clear enough to guide selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it merely restates the operation. It does not disclose that deletion is irreversible, whether it is a soft or hard delete, what happens to associated data, or what the 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?

The description is a single, front-loaded sentence with no filler. It is concise and readable, though slightly redundant with the title and omits useful behavioral context that would not hurt the flow.

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 tool with no annotations and no output schema, the description is thinner than it should be. The agent can infer how to call it from the schema, but it is not told what happens after deletion, whether the action is reversible, or what consequences to expect.

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

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

Schema description coverage is 100% and the id parameter is documented as 'Entry id from entry_list.' The description adds little beyond that, only restating that deletion happens 'by id,' so it meets the baseline but does not elevate parameter understanding.

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 action ('Delete'), a clear resource ('time entry'), and the method ('by id'). This is distinguishable from sibling tools like entry_edit or entry_mark_billed because the verb and target are explicit and 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?

No guidance is given about when to use this tool versus entry_edit, entry_add, or other time-entry tools. The description does not mention prerequisites, alternatives, or any exclusions, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the most important behavior: this is a partial update and omitted fields are left untouched. It does not mention validation behavior, permissions, side effects, failure modes, or the return value, leaving moderate transparency gaps.

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

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

Two short sentences with no filler. The key partial-update caveat is stated immediately after the action, making the description easy to scan and process.

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 an 11-parameter mutation tool with no annotations and no output schema, this description is under-specified. It gives enough to attempt a simple edit, but does not explain return semantics, error/validation behavior, or the meaning of several fields, so an agent cannot fully predict the outcome of calling the tool.

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

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

The schema documents only 6 of 11 parameters (55%), so field descriptions are incomplete. The description adds a useful generic semantic—only supplied fields are changed—which affects how all parameters should be interpreted. However, it does not clarify ambiguous fields like task, project, tags, note, or billable, so the added parameter meaning is shallow.

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 action ('Change fields') on a specific resource ('existing entry'), and the title clarifies it is a time-entry edit. It is distinguishable from entry_add, entry_delete, and entry_list, though it does not explicitly name an alternative, so it stops short of a perfect score.

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 'existing entry' implies this tool is for modifying already-created time entries, and 'Only the fields you pass are changed' implies a partial-update workflow. However, there is no explicit when-to-use/when-not-to-use guidance or routing to entry_add/entry_delete, so usage context is only implied.

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?

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?

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?

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?

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?

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?

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 main behaviors: entries get stamped, reports and invoice_summary stop offering them, and double-billing is prevented. The ids parameter description adds that already-billed entries are left alone and listed back, which is useful idempotency behavior. It does not detail reversibility or permissions, but the core mutable effect is transparent.

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

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

The description is one tight sentence that front-loads the purpose and consequence. Every clause earns its place, with no repetition of the title or 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 mutation tool with no output schema and no annotations, it covers what it does, when to run it, why it exists, and how to select entries. Minor gaps are an explicit statement of what is returned for successfully billed entries and whether the change can be undone, but the tool is callable with the information provided.

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 descriptions already cover parameters, so the baseline is 3. The description adds meaningful selection semantics: 'Pass either ids or project plus from and to' plus the typical source 'entry_ids invoice_summary returned'. This clarifies the two mutually exclusive calling modes and helps an agent avoid passing conflicting parameters.

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

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

The description uses a concrete verb and object ('stamp the tracked hours ... with the invoice number') and explains the business purpose ('so report and invoice_summary stop offering them and the same hours are never billed twice'). This clearly differentiates it from siblings like invoice_mark_paid, which marks an invoice paid rather than the underlying time entries.

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 an explicit trigger condition ('after an invoice is issued') and references invoice_summary as the source of entry ids, making the workflow placement clear. It does not enumerate exclusions or alternatives, but an agent can infer when this tool is the right step.

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 burden of explaining behavior. It discloses that a new .ics file is written, that UTC times are used, and that the file is intended for sending or importing elsewhere. It does not describe error cases or what happens if both ids and from/to are supplied, but the core behavior is transparent.

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

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

Two focused sentences, no filler. The purpose and key usage distinction are front-loaded, and the timezone detail is placed where it matters. Every sentence earns its place.

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

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

The description is adequate for a straightforward export tool, but gaps remain: it does not clarify what happens when both ids and from/to are omitted or supplied together, and it only references events_list as the source for ids while the schema also allows events_search and next_event. With no output schema, a bit more detail about expected results would strengthen completeness.

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 meaningful cross-parameter guidance by presenting ids and from/to as mutually exclusive alternatives, and explains why UTC matters for the output. This goes beyond simply restating 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 action and resource: 'write chosen events to a new .ics file'. It clearly separates this from siblings like export_csv or ics_create by focusing on exporting existing events into an .ics file.

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 clearly tells the agent how to scope the operation: pass either ids or a from/to window. It does not explicitly name sibling tools to avoid, but the context of sending or importing the .ics elsewhere is clear enough for correct 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It usefully communicates recurrence expansion, sorting by start, timezone fallback behavior, and ID reusability. It does not describe response shape or pagination, but still provides meaningful behavioral context beyond a simple 'list events' statement.

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, information-dense sentences: the first states scope and ordering, the second clarifies timezone behavior, and the third explains useful downstream tool compatibility. Every sentence 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?

For a simple list operation with no output schema, the description covers the essential behavioral context: date window, recurrence expansion, sorting, timezone handling, and ID usefulness for related tools. It does not detail the response envelope, but the gap is modest given the clear scope and title.

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 already documents all four parameters with 100% coverage, so the description does not need to define them. It adds one useful nuance about the 'zone' parameter and local time display, which goes slightly beyond the schema, but the schema remains the primary source of parameter meaning.

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

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

The core behavior is clear: 'Every event between two dates, recurring expanded to occurrences, sorted by start' names the resource and the operation. It does not explicitly contrast with sibling tools like events_search, so differentiation is implied rather than stated.

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

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

The description implies this tool is for retrieving all events in a date range and notes that resulting IDs work for event_export or event_to_time_entry. However, it does not explicitly say when to use events_list versus events_search, free_busy, next_event, or other calendar-related siblings.

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 discloses plan-dependent default time ranges, giving some insight into behavior, but it does not explicitly state that the operation is read-only or describe any side effects, rate limits, or data sensitivity.

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

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

The description is two concise sentences, with the main purpose stated upfront and additional behavior details in the second sentence. No fluff or redundancy 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?

In the absence of an output schema, the description does not clarify the return format (e.g., list of event objects, count, metadata). While 'find events' implies a result set, the lack of detail on what the response contains could leave an agent uncertain about downstream processing.

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 description adds meaningful context by explaining how from/to behave when omitted (default windows) and what fields are searched. This goes beyond the schema's simple date and query definitions, providing practical usage semantics.

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 ('find') and clearly identifies the resource (events) and the search scope (title, description, location, attendees). It distinguishes this from a plain listing tool by emphasizing the phrase search across imported calendars.

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 it searches every imported calendar and describes default date windows based on plan, but it does not explicitly mention when to prefer this over sibling tools like events_list or how it differs from them. Guidance on when-not-to-use or alternatives is missing.

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?

Explicitly states 'Writes nothing', which is a key side-effect disclosure given the lack of annotations. It also clarifies that it returns arguments rather than performing the entry creation, but doesn't mention potential validation or error 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?

Two concise sentences with no redundant wording. The key information—what it does, its side-effect-free nature, and the follow-up action—is front-loaded and efficiently communicated.

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?

Sufficient for a tool with 4 straightforward parameters. It tells the user exactly what to do with the output ('pass the JSON straight to entry_add'), though a bit more detail about the return shape would have been helpful given the absence of an output schema.

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

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

The schema already covers all parameter meanings (event_id source, project/client, rate format, currency fallback). The description adds no extra parameter detail, so it stays at the baseline for full 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?

Clearly states it takes an event and returns the exact arguments for entry_add, with the specific purpose of converting a past meeting into billable time. This distinguishes it from sibling tools such as entry_add or events_list.

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?

Indicates when to use it ('a meeting that already happened becomes billable time') and directs the user to pass the result to entry_add. It doesn't explicitly contrast with every alternative, but the use case is clear.

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 write behavior ('Returns the file path written'), the output content, and the format. It does not mention overwrite or clamping behavior, but the input schema already documents the free-tier/pro clamping for date ranges.

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 primary purpose, and every sentence adds essential information: what it exports, for whom, the row structure, and the return value. No filler or redundancy.

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

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

With no output schema, the description correctly explains the return value ('file path written') and the file content. It covers the essentials for an agent to select and invoke the tool. Minor omissions like file overwrite behavior or encoding are acceptable given the schema richness and simple nature of the export operation.

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

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

Schema description coverage is 100% with clear descriptions for all four parameters (to, from, path, project). The description does not add parameter-specific meaning, but the baseline of 3 is appropriate because the schema fully covers the parameters.

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

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

The description states a specific verb ('export'), resource ('the timesheet'), output format ('CSV file, excel-friendly'), and purpose ('hand to a bookkeeper'). It also specifies the row structure ('one row per entry with hours, billable, rate, currency and amount'), which clearly distinguishes it from other export-related siblings like clause_export or event_export.

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

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

The description explicitly tells when to use the tool ('Call this tool to export the timesheet to a CSV file...') and for whom ('hand to a bookkeeper'). It does not name alternative tools or state when not to use it, but among the siblings there is no direct alternative for timesheet CSV export, so the guidance is clear.

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 transparency burden. It does disclose return content (UTC instant, local time per participant, fairness score) and ordering, but it leaves side-effect/read-only status implicit and does not mention behaviors like saved-contact resolution or free-tier truncation, although some of those appear in the schema descriptions.

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

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

Two concise sentences lead with the core action and then describe the output shape and ordering. No filler, no repetition of schema content, and every sentence earns its place.

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

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

There is no output schema, but the description usefully summarizes the return values, and the rich parameter schema covers the inputs thoroughly. It is complete enough for correct invocation, though explicit usage guidance and side-effect disclosure would make it fully self-sufficient without 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?

Schema description coverage is 100%, so the schema already explains every parameter. The description adds context about output format and ranking but no additional parameter-level meaning, matching the baseline of 3.

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

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

The description uses a specific verb ('Rank') and clear resource ('times when every participant is inside their own working hours'), and separates this tool from siblings like free_busy or conflicts by describing the fairness-ranked slot output. The title and description together leave no ambiguity about what the tool does.

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

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

Usage is implied: the tool clearly exists for finding mutually workable meeting times across participants. However, it does not explicitly say when to choose this over alternatives like free_busy, conflicts, or overlap, nor does it state when not to use it.

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 disclosure burden. It adds meaningful traits: the forecast is 'expected' rather than actual, it aggregates by calendar month and currency, it draws from 'every active schedule', and it varies by plan tier. It does not mention return format or error behavior, but the core behavioral scope and limitations are conveyed.

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

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

The description is two concise sentences with no filler. The main purpose and output granularity are front-loaded, and the plan limitation is stated efficiently in the second sentence.

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

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

For a single-parameter tool with no output schema and no annotations, the description explains what the result contains, the data source, the time horizon, and plan-based limits. It lacks explicit mention of the response structure or error conditions, but the tool is simple enough that agents have sufficient context to invoke it correctly.

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

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

Schema coverage is 100% and already documents months as an integer with min, max, and default. The description adds valuable plan-dependent semantics: Free accounts are limited to 3 months while Pro allows up to 120. This helps an agent decide whether a requested months value is feasible before calling.

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 defines the tool as producing expected invoiced revenue per calendar month per currency, with the scope being active schedules. This is more specific than a bare restatement of the title, but it does not explicitly differentiate from close sibling tools like invoice_summary or overdue_report.

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

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

The description gives no direct 'use this when' guidance, nor does it name alternatives or exclusions. The Free/Pro month limits imply some usage constraints, but there is no explicit advice on when to choose this tool over its finance-focused siblings.

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 transparency burden and does a solid job, explicitly stating the merging behavior, the exclusion of free/transparent events, and that whole-day events block the day. It does not mention read-only behavior or return shape, but the core behavioral traits are 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, information-dense sentence with a memorable opening phrase and no filler. Every clause contributes a meaningful detail about behavior or scope.

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 has six parameters and no output schema, so the description needs to cover key semantics and likely outcomes. It explains the busing rule, the free-window concept, and important calendar event behavior. It stops short of describing exact output fields or timezone handling, but those are partly covered by 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 parameters are already well documented. The description only loosely maps to 'calendars named' and 'working hours', adding little 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?

The description clearly states the tool's function: it returns merged busy blocks from selected calendars and free gaps within working hours. It also differentiates itself from calendar-listing or event-searching tools by focusing on availability windows and busy merging.

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 sets the context well: use this when you need to know where time is booked and where free windows remain within working hours. It does not explicitly name sibling alternatives or state when-not-to-use, so it misses full exclusion 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. It discloses the return value and its purpose, but does not explicitly state read-only/non-mutating behavior, rate source, freshness, or error conditions. It is adequately transparent for a lookup, but not exhaustive.

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 when to use, followed by the return contract. No filler or redundancy.

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

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

For a simple two-parameter read tool with a thorough schema, the description covers when to call it and what it returns. The main gap is that the output shape is defined only by reference to 'expense_to_invoice', which may be ambiguous if that concept isn't known to the agent.

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

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

Schema description coverage is 100%, with good detail about target, currencies, direction, and defaults. The description adds no additional parameter meaning beyond what the schema already explains, so baseline 3 applies.

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

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

clear and specific: it is a call-to-get FX rates for multi-currency invoices/rebills, returning a shaped object and rate date. It does not explicitly contrast itself with sibling rate tools like rates_latest or convert, so it stops short of full sibling differentiation.

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

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

Gives an explicit trigger condition (rebill or invoice spans more than one currency) and an explicit alternative (asking the user for rates). It lacks comparison to sibling FX rate tools, so it doesn't fully cover when-not-to-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 must carry behavioral weight. It does disclose the main side effect (writing a file) and the return values (path and meeting time). However, it does not mention overwrite behavior, whether invites are sent, error handling, or DST edge cases, which leaves important behavior implicit.

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

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

Two sentences with no filler. The purpose is front-loaded and the return information is concise and useful. Every word 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 12-parameter tool with no annotations and no output schema, the description is minimal but adequate. The rich schema covers parameter details, but the description lacks explicit sibling differentiation, overwrite/safety behavior, and a fuller picture of the return format.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no parameter-level meaning beyond saying the meeting time is returned in UTC and the provided zone, which is output behavior rather than parameter semantics.

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 action — write a .ics calendar file for one meeting — and clearly identifies the resource. This distinguishes it from nearby siblings like ics_import and event_export, since the focus is on creating a single .ics file.

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 clear context for when to call the tool: write a .ics calendar file for a single meeting. It does not explicitly name alternatives or when-not conditions, but the intended use case is unambiguous despite the large sibling set.

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 present, so the description carries full behavioral disclosure. It explicitly states that both the calendar and its local .ics copy are removed and that nothing else is touched. This gives strong clarity on the destructive scope and side effects, though it omits failure modes or reversibility.

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 core action front-loaded and a clear no-side-effect clarification. Every word contributes to the meaning; there is no redundancy or unnecessary detail.

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

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

Given the simplicity of the tool, one fully documented parameter, and no output schema requirement, the description covers the essential knowledge needed to use it safely: exactly what will be removed and what will not. Any missing details like not-found handling are negligible for a focused delete 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?

The schema already provides a full description for the only parameter (name: 'The calendar name from calendars_list'), so the tool description adds minimal parameter-level meaning. The phrase 'imported calendar' hints at the domain but does not add syntax, format, or constraints beyond the schema. Combined with 100% schema coverage, baseline 3 is appropriate.

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

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

States a specific action with verb and resource: 'Remove one imported calendar and the local copy of its .ics file.' 'Nothing else is touched' adds a precise scope boundary, distinguishing it from broader deletion operations and showing it is the inverse of ics_import.

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 context is implied by the term 'imported calendar' and the tool name ics_forget, but there is no explicit when-to-use statement, named alternative, or exclusion such as 'use this instead of deleting the calendar.' The description tells what it does but not specifically when to choose it over other actions.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that re-importing a name replaces the existing entry and that URL feeds are a Pro feature, but it does not describe the return value, success/failure behavior, or persistence semantics beyond 'keep it under a name.'

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

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

Three compact sentences, front-loaded with the main action and no filler. Each sentence contributes a distinct piece of information: the operation, the input modes, provider compatibility, and overwrite behavior.

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?

Inputs and the important replace-on-reimport behavior are covered, and the schema documents all four parameters. However, because there is no output schema and no annotations, the agent is left without any stated return value or error semantics, which is a meaningful gap for an import operation.

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

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

Schema description coverage is 100%, so the baseline is 3. The main description adds helpful context by naming path, text, and URL as input alternatives and noting Pro for URLs, but it does not clarify whether exactly one source is required or what happens if multiple are supplied.

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

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

States a concrete action: read an .ics export and store it under a name. It clearly identifies the resource and avoids tautology, though it does not explicitly differentiate itself from sibling calendar tools like ics_create or ics_forget.

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?

Opens with a direct 'Call this tool to...' directive, so the primary use case is clear. It names the three input modes and flags the Pro requirement for URLs, but gives no explicit when-not-to-use guidance or routing among the many calendar-related siblings.

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 does disclose a genuine side effect — persistence to a shared profile consumed suite-wide — and the one-time intent ('Call it once, first'). However, it does't state whether a subsequent call with only a subset of fields merges into or overwrites previously stored values, nor does it mention any return/confirmation, both of which matter for a write tool with 15 optional fields.

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

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

Two sentences with the scoping claim front-loaded. The content list, persistence fact, and usage directive each earn their place, and there is zero filler. The emphatic 'ONE' may be stylized but it functionally reinforces differentiation from sibling tools.

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-time setup call, the description covers scope, contents, persistence, and invocation order, and the rich schema covers parameter details. The remaining gaps are partial-update semantics on re-invocation (merge vs overwrite) and explicit routing relative to docx_business_set; with no output schema there is no hint at the return either.

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%, the baseline is therefore 3. All 16 fields are already documented in the schema, including alias relations (vat/tax_rate/vat_rate → default_tax_rate) and the conditional email/phone rules. The description adds only high-level category grouping (name, address, VAT id, bank details, defaults) and no per-parameter meaning.

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

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

The description clearly identifies the resource — the single suite-wide business profile — and enumerates its contents (name, address, VAT id, bank details, defaults). It differentiates from siblings by declaring itself 'THE ONE...for the whole suite' and stressing that 'every other server reads' it, which separates it from docx_business_set and prophile_set/prophile_get, though it never naes 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?

'Call it once, first' is an explicit temporal instruction placing this tool before any other invoicing work, and the claim that the profile is what 'every other server reads' tells the agent this is the shared setup entry point. No when-not-to-use guidance or naed alternatives are given, so it doesn't quite reach a 5.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses that a new invoice number is allocated and never reused, that the invoice is persisted ('stored'), and that the call returns subtotal, discount, per-rate tax lines and total. These are behavioral facts beyond the bare 'create' verb, though side effects like auto-creating unknown clients appear only in the schema.

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

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

Two sentences with zero filler; the core purpose is front-loaded and the second sentence packs the key behaviors (numbering, return shape). Every phrase 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 7-param creation tool with no annotations and no output schema, the description covers the essential procedural facts — number allocation, persistence, return structure — while the richly detailed schema handles currency-mixing refusal, aliases, and D-R24/D-R46 rounding rules. The division of labor is sensible; the description would only need to add more if the schema were thinner.

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 and the schema already documents all 7 parameters in detail. The description adds marginal context by hinting that discount and per-rate tax lines appear in the returned invoice, mapping loosely to discount_percent and tax_rate, but it adds no syntax or format 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 and resource ('Create an invoice') plus the exact scope ('for a client from a list of items'). The qualifier 'from a list of items' distinguishes it from siblings like invoice_from_hours and invoice_generate_due without opening their 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?

The phrase 'from a list of items' implies the itemized-billing use case, but the description never names alternatives or states when not to use it. No explicit exclusion routes the agent toward invoice_from_hours or invoice_generate_due; the usage is inferred 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?

With no annotations, the description carries the behavioral disclosure burden. It clearly states the side effect ('Creates... an invoice') and the result behavior ('returns a single-line invoice, converting the rate... and echoing back any entry_ids'). This gives an agent a solid sense of what will happen, though it could also mention that the invoice is not automatically marked billed until entry_mark_billed is called.

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 essential use case, then the key behavioral details. Every sentence adds value without unnecessary elaboration or restating the tool name.

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

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

Despite a rich schema, the tool has 14 parameters, no annotations, and no output schema, so the description alone is not enough for an agent to fully understand the return shape or the full behavior across optional parameters. It explains the core case well but leaves significant context to be inferred from 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?

The description adds meaning for the core fields client/hours/rate and the relationships around fx_rates and entry_ids, but schema coverage is only 50% and many optional parameters (notes, due_days, tax_rate, discount_percent, issue_date) are not addressed in the description. It partially compensates for the schema gap but does not fully carry the burden for all 14 parameters.

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

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

States a specific operation: 'Creates and returns a single-line invoice' for bill one client for N hours at an hourly rate. Differentiates from sibling tools like invoice_create by framing it as a 'Shortcut' for the common case, making its scoped purpose clear.

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

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

Provides clear context for when to use it: 'Shortcut for the common case: bill one client for N hours at an hourly rate.' It also notes the conversion behavior when fx_rates is provided. It falls short of explicitly naming alternatives or saying when not to use it, but the context strongly implies its intended niche.

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

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

With no annotations, the description carries the burden of disclosing side effects, and it does: it creates 'real' invoices, renders PDFs, and returns a summary of created, skipped, and still-due items. The parameter descriptions add idempotency, dry-run, and limit details, further improving transparency.

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 tight sentences: it leads with the core behavior and follows with the return summary. No redundant phrasing or filler, and it is well-structured for quick agent parsing.

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 has no output schema, but the description names the three return categories and the parameter descriptions cover defaults, idempotency, dry-run, and the 60-invoice cap. This is sufficient for an agent to invoke the tool correctly, though return structure details are absent.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the schema. The main description does not add parameter-level meaning beyond the schema, which matches the baseline of 3 for high 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 states a specific action: create real invoices for schedule occurrences on or before as_of that haven't been invoiced, and render PDFs. This clearly identifies the resource and behavior, distinguishing it from siblings like invoice_create or invoice_from_hours by focusing on schedule-driven batch generation.

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 context is implied: this is for generating due invoices from schedules, especially in bulk. However, it does not explicitly state when to choose this over alternatives like invoice_create or invoice_from_hours, nor does it mention any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden, and it does well by disclosing not just that it returns a record but also the nested richness of that record, including the unusual credit-note-adjusted open balance. It does not discuss error cases or permissions, but the read-only nature is clear from 'Return'.

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 that efficiently conveys the core purpose and key return-value details. The parenthetical '(see credited_minor)' is somewhat cryptic and unexplained, slightly reducing clarity, but overall there is no wasted wording.

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

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

For a simple single-parameter get operation with no output schema, the description covers the essential information an agent needs: what it returns, the scope ('one invoice number'), and notable computed fields. It could be more complete with explicit not-found behavior, but the core call context is adequately covered.

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 only documents 'number' as a string with zero description coverage. The tool description adds that it identifies the invoice, which is minimal but useful; it does not specify format, uniqueness requirements, or how to discover valid invoice numbers.

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 ('Return') with a clear resource ('the full stored record for one invoice number'), making the tool's purpose unmistakable. It also highlights distinctive content (line items, tax breakdown, credit-note-adjusted balance) that separates it from siblings like invoice_summary or invoice_list.

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

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

The description implies when to use the tool: when you have an invoice number and need the full record rather than a summary. However, it does not explicitly contrast it with alternatives such as invoice_summary, invoice_list, or invoice_pdf, leaving routing decisions partly to inference.

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