LeaseCommand

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

Annotations already declare this a safe, idempotent, closed-world read, so the safety profile is covered. The description adds real value by enumerating the returned sections and by stating the non-fabrication rule when a schema is missing, but says nothing about error behavior for an unknown operationId.

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 returned content, with the fallback rule second. The closing clause about accounting evidence is domain-flavored but still earns its place as a guardrail.

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

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

For a one-parameter read tool with no output schema, the description adequately covers what is returned. It is incomplete on the single input (where operationId comes from) and on behavior for unknown IDs, which is the main thing an agent could get wrong.

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

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

Schema coverage is 0% — operationId has no description in the schema. The description says 'registered operation' but never explains the 24-hex-character format, that it must come from search_operations, or what happens with an unregistered ID, so it does not compensate for the coverage gap.

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

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

States a specific verb and resource (get a registered operation) plus the concrete payload: method, path parameters, query and body schemas. An agent knows exactly what comes back, though it never differentiates itself from search_operations, which appears to be the discovery counterpart.

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

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

The only guidance is a fallback rule for absent schemas (use app API documentation and validation feedback, don't invent accounting evidence). Nothing says when to pick this over search_operations or execute_read, nor how an operationId is obtained in the first place.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), yet the description still adds real context: organization scoping, that it runs under normal user permissions, that calls are audit-logged, and that exports/large results come back as a bounded downloadable result. That result-shape and audit disclosure is exactly the kind of thing annotations cannot express; only error behavior for an invalid operationId is left out.

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, no filler, and the scoping/permission constraint is front-loaded before the result-shape caveat. Every clause carries information an agent would otherwise have to infer.

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 generic gateway with 0% parameter documentation, no output schema, and nested untyped objects, the description answers too few of the questions an agent must resolve before calling it: where the operationId comes from, what the query/params maps accept, and what happens on failure are all missing.

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

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

Schema description coverage is 0% and all three parameters include nested free-form objects, so the description must carry the burden and it does not. Neither 'operationId' (a 24-hex id whose source is unstated), nor the opaque 'query' and 'params' objects (string-valued, 2000-char capped) is explained, leaving an agent to guess what goes into them.

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

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

The verb+resource pairing ('Execute... GET operation') is real but abstract: an 'operation' is the gateway's own concept, and the description never says how operations are identified or that they are looked up elsewhere. It also fails to distinguish this generic executor from the many concrete get_* siblings that overlap with it.

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

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

There is no when-to-use guidance at all: no mention of describe_operation or search_operations to obtain the required operationId, no statement of when to prefer this gateway over the dedicated get_* tools, and no indication of when read_download (the obvious alternative for bounded exports) should be used instead.

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

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

Annotations already establish readOnly, idempotent, non-destructive behavior, so the description's added value is the authorization scope and bounded result set. That is useful behavioral context beyond the annotations, although 'bounded' and 'authorized source selection' are not explained concretely.

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 only two sentences and front-loads the primary purpose before the alternative. It is efficient, though 'bounded authorized source selection' is jargon that could be replaced with clearer language.

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 annotations and no output schema, the description covers purpose and an alternative but leaves parameter meanings and result-set limits underexplained. Given 0% schema description coverage, it does not fully compensate for what the schema omits.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. 'By text' weakly implies that q is a text query, but page is entirely undocumented in both schema and description, so an agent must infer its 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?

States a clear verb and resource: find existing organization contracts by text. The purpose is understandable without opening the schema, though the phrase 'bounded authorized source selection' is vague and the alternative 'generic catalog' is not named precisely.

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?

Explicitly directs the agent to use the generic catalog for additional filters or deeper records, which gives a when-to-use-this-vs-alternative condition. The guidance would be stronger if the generic catalog tool were named and if exclusions for this tool were clearer.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is fully covered elsewhere. The description adds that results are a "bounded authorized source selection," hinting at result caps and permission scoping, which is genuinely beyond the annotations, but it never states how bounded, how authorization is determined, or how paging behaves.

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

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

Two compact sentences with the primary action front-loaded and the fallback stated second. "Bounded authorized source selection" is somewhat jargon-heavy but is the only thing carrying behavioral information, so it 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 search tool with zero schema descriptions, no required params and no output schema, the description should explain result shape and pagination expectations. It gestures at bounded results but omits result size, paging semantics, and whether q is optional-and-returns-everything, which is critical given 0 required parameters.

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

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

Schema description coverage is 0%, so the description carries the whole burden. "By text" loosely maps to q, but nothing explains the 200-character limit, matching/ranking behavior, or what the page parameter does (size, ordering, whether bounds interact with the "bounded selection"). Substantial compensation is 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?

"Find existing organization sites by text" gives a specific verb (find), resource (organization sites) and search method (by text), so an agent can tell it apart from the ID-based get_sites_by_id family. It does not explicitly distinguish itself from sibling get_sites or the sitefolio location tools, leaving partial 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?

It points to "the generic catalog" for additional filters or deeper records, which is a useful routing hint. But the alternative is unnamed and does not match any obvious sibling in the provided list, and there is no statement of when NOT to use this tool (e.g., vs get_sites for a full 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered structurally. The description adds nothing beyond that - no return shape, no pagination, no filtering behavior, no note about what the mapping resource represents.

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?

Short, but the first two sentences are the identical URL string repeated verbatim - pure duplication with zero information gain. Front-loading is absent because there is no substantive content to front-load.

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

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

No output schema and 0% parameter coverage mean the description must carry the burden, and it does not: no purpose, no parameters, no behaviors. The single pointer to describe_operation and execute_read-adjacent siblings is the only useful fragment.

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

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

Schema description coverage is 0% and both parameters ('query' as an arbitrary property bag and empty 'params') are undocumented. The description does not compensate at all; it only points at describe_operation for the real request schema, which is a pointer rather than 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 merely restates the tool name as a raw URL path ('GET /api/accounting/account-mappings') twice. It implies a listing of account mappings but does not describe what a mapping is, what it contains, or how it differs from near-identical siblings such as get_account_mappings_5900b624a5f0d38407bcecf4, get_account_mappings_by_id_..., or get_account_mappings_effective_....

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

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

There is no statement of when to use this tool versus the many account-mapping siblings in the same namespace. The only guidance is the note that describe_operation provides native request schemas, which hints at how to discover parameters but says nothing about tool 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without the description. The description adds nothing behavioral beyond the schema-lookup hint — no mention of pagination, filtering, response shape, or rate limits.

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

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

Very short, but the first sentence is duplicated word-for-word and the remainder is a bare operation ID, so there is no front-loaded useful content. Brevity here reflects under-specification rather than efficiency.

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 endpoint with free-form nested query objects, no output schema, and 0% parameter documentation, the description leaves an agent unable to know what filters to pass or what comes back. The describe_operation pointer is the only lifeline, and it forces a second round-trip.

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

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

Schema description coverage is 0% and the two parameters ('query' and 'params') are untyped free-form objects with additionalProperties, so the schema explains nothing. The description does not compensate at all — it never mentions what query keys are accepted or what 'params' is for.

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 is essentially the tool name and HTTP path repeated verbatim ('GET /api/accounting-books. GET /api/accounting-books.'), which restates the title rather than explaining what an 'accounting book' is or what the response contains. The only added information is an opaque operation ID, which does not help an agent understand purpose.

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

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

The single usable signal is 'describe_operation provides native request schemas', which hints at a prerequisite lookup, but there is no statement of when to call this versus the dozens of sibling accounting endpoints (account mappings, contracts, journal entries, GL accounts). No exclusions, no context conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds nothing beyond that — no indication of what the settings object contains, whether it is workspace-scoped, or any auth/rate-limit context; the only added value is the pointer to describe_operation.

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

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

The first sentence is repeated verbatim, wasting space in an already minimal description. No real content is front-loaded because there is no content beyond the path.

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 nested-object, zero-coverage parameter schema with no output schema and no annotations on data shape, the description must explain what is retrieved and how to call it — it does neither, so an agent would have to fall back to describe_operation for anything useful.

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

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

Schema description coverage is 0% and the two parameters are opaque ('query' as a free-form object with additionalProperties: {} and an empty 'params'). The description supplies no parameter meaning at all, leaving an agent unable to know what a query object on this endpoint would even accept.

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 only echoes the URL path and title, 'GET /api/accounting/compliance-settings', which is a tautology of the tool name rather than an explanation of what the endpoint returns or why compliance settings matter. It does not distinguish this tool from any of the many other accounting GET endpoints in the sibling 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?

There is no statement of when to use this tool, when not to, or which sibling to prefer. The only actionable hint is that 'describe_operation provides native request schemas', which points at a companion tool but offers no selection criteria between this and, say, get_settings_* or get_compliance_rules_* 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds nothing beyond the URL — no return shape, pagination, or scope information — and the duplicated sentence wastes space rather than adding behavior detail.

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 same endpoint string appears verbatim twice, which is pure redundancy, and there is no front-loaded explanatory sentence. It is short but only because content is missing, not because it is efficient.

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

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

Two parameters, a nested untyped query object, 0% schema coverage, and no output schema — the description should carry this burden but instead defers entirely to describe_operation. An agent cannot call this correctly from the description alone.

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

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

Schema description coverage is 0% and nested query/params objects are undocumented. The description says nothing about contractId or the free-form query object; the pointer to describe_operation is the only compensating hint, and it offloads rather than explains.

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 is only the raw route 'GET /api/accounting/contracts/:contractId/payment-schedule' repeated twice, from which an agent can infer it fetches a contract's payment schedule. There is no plain-language statement of the verb+resource, and nothing distinguishes it from the four sibling 'get_accounting_contracts_by_contractId__*' tools, which are different endpoints on the same resource.

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

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

No guidance on when to use this versus the other contract-by-contractId endpoints or find_contracts. The only actionable hint is 'describe_operation provides native request schemas', which directs to a schema lookup tool, not to selection criteria.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description contributes nothing beyond that — no pagination behavior, no scoping rules (does query support filters? date ranges?), no note on what a missing contractId returns. It is not contradictory, just empty.

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?

Short, but the same endpoint path appears twice back-to-back with no added information the second time. Brevity here comes from under-specification rather than economy; there is no front-loaded statement of what the tool returns.

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

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

No output schema exists, so the description should carry the burden of explaining return shape, and it does not. With a nested query object at 0% schema coverage and no examples, an agent cannot confidently construct a call without first invoking describe_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 0% for both parameters, and the description says nothing about contractId or the fully free-form query object (additionalProperties: {}). The single mitigation is the reference to describe_operation, which tells the agent where to look for request schemas but documents no semantics itself.

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 text is the raw endpoint path repeated verbatim, plus an operation ID. It implies reading journal entries scoped to a contract, but it never says 'retrieve journal entries for a contract' in a way that adds anything over the tool name and title. Among dozens of near-identical get_accounting_contracts_by_contractId__* siblings, an agent gets no help distinguishing what makes this one different.

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

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

There is no when-to-use, when-not-to-use, or sibling routing guidance. The only actionable information is the pointer to describe_operation for native request schemas, which is a discovery hint rather than usage guidance. Alternatives such as get_journal_entries_readiness or get_accounting_journal_entries_by_id_ap are left entirely unaddressed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds no behavioral context beyond that — no mention of what the profile payload covers, auth requirements, or pagination.

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 same endpoint path is repeated in two consecutive sentences with zero added information, wasting half the text. The only unique content — the operation ID and the `describe_operation` pointer — is buried at the end.

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

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

With no output schema and 0% schema coverage on a two-parameter tool, the description should explain the returned profile shape and the meaning of `contractId`; it does neither. The `describe_operation` reference partially mitigates the missing request schema, but overall the definition is inadequate for correct selection and invocation.

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

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

Schema description coverage is 0%, so the description must compensate and does not: `contractId` is never explained (format, source, whether it is the internal ID vs. contract number), and the free-form `query` object is not mentioned at all. The path template is the only implicit hint about the required parameter.

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

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

The description only restates the title/endpoint path verbatim, twice, without explaining what a contract 'profile' contains or how it differs from the several sibling endpoints with the same `/accounting/contracts/by_contractId/...` shape. The HTTP verb and resource path are recoverable, but the semantic purpose is not 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?

There is no guidance on when to call this versus the numerous sibling contract sub-resource endpoints (e.g. the other `get_accounting_contracts_by_contractId__*` tools). The only actionable pointer is that `describe_operation` holds the native request schema, which is a schema-lookup hint, not a usage rule.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds nothing beyond the path — no pagination, filtering, or result-shape context — so it does not enrich what annotations provide.

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 same path is repeated verbatim in two consecutive sentences, and an opaque operation ID is included that adds no selection value. Nearly the whole text is redundant or noise rather than front-loaded guidance.

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

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

A nested-object, 0%-coverage, GET endpoint with no output schema needs the description to explain the query object and return payload. Neither is addressed; the only useful pointer is the deferred reference to describe_operation, which offloads the actual specification.

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

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

Schema description coverage is 0% and two parameters (a free-form 'query' object and 'params.contractId') have no descriptions anywhere. The path string only implicitly names contractId; the 'query' parameter is completely undocumented in both schema and description, leaving the agent to guess accepted filter keys.

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 raw path 'GET /api/accounting/contracts/:contractId/modifications' does encode a verb and resource, and the 'modifications' suffix distinguishes it from the many sibling get_accounting_contracts_by_contractId__* endpoints. But the tool name itself ends in a hash, so the only disambiguation comes from the URL string, never restated in plain language as 'list contract modifications'.

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

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

There is no statement of when to call this versus the sibling /modifications endpoints or versus find_contracts. The only procedural hint is 'describe_operation provides native request schemas', which points at another tool but does not describe conditions for use.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered elsewhere. The description adds nothing about response shape, pagination, or what the amortization schedule covers, so it earns little beyond the structured 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?

The same URL sentence is repeated verbatim, which is pure waste, and the remaining text is an internal operation ID. Nothing is front-loaded as a human-readable purpose statement.

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

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

With no output schema, no annotation gaps to fill, and 0% parameter documentation, the description would need to explain the endpoint's semantics and the undeclared query parameter. It does neither, leaving an agent to consult describe_operation for anything beyond the URL.

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

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

Schema description coverage is 0% for two parameters (required contractId, optional free-form query). The description only echoes ':contractId' from the path and never explains the query object or the contractId's expected form, so it fails to compensate for the coverage gap.

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

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

The repeated URL line does convey a verb (GET) and resource (amortization schedule for a contract), so the intent is inferable. But it is a bare endpoint path with no plain-language explanation of what an amortization schedule response contains, and the duplication adds nothing.

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

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

No guidance on when to call this versus the many sibling contract sub-resource endpoints or execute_read. The only routing hint is a pointer to describe_operation for request schemas, which is about schema discovery, not tool 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds no behavioral context of its own — no auth requirements, no scope/id resolution behavior, no error conditions.

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 first sentence is duplicated verbatim, which is pure waste rather than emphasis. The remaining content is an operation ID and a pointer, so there is no front-loaded substance to be concise about.

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

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

There is no output schema, so the description could have described the returned dimension record, but does not. Combined with 0% parameter documentation and a nested params object, an agent would have to call describe_operation first to use this tool at all.

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

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

Schema description coverage is 0% for two critical path parameters (scope, id) plus an open-ended query object. The description says nothing about what values scope accepts, what id identifies, or how query filters work, so it fails to compensate for the coverage gap.

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

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

The description restates the endpoint path already present in the title and tool name, twice, without explaining what a 'financial dimension' is or what :scope distinguishes. An agent cannot tell this apart from the hundreds of other get_accounting_* siblings on the basis of the text.

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

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

There is no statement of when to use this tool, no prerequisites, and no named alternative among siblings. The only actionable hint is that describe_operation holds the native request schemas, which is a lookup pointer rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds no behavioral context of its own: it says nothing about required scoping (query is a free-form object), currency pair semantics, rate precision, or caching/staleness of FX rates, which is exactly the kind of detail a spot-rate lookup needs.

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

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

It is short, but the first sentence is repeated verbatim and the operation ID is technical boilerplate for the agent. No sentence is front-loaded with actionable meaning beyond the raw path.

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

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

With a free-form query object, no output schema, and zero parameter documentation, the definition leaves the agent unable to construct a valid call without first invoking describe_operation. For a tool whose entire input is untyped, the description should carry the burden and does not.

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

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

Schema description coverage is 0% and the two parameters are a free-form `query` object with additionalProperties and an empty `params` object. The description provides no parameter meaning at all — no mention of which query keys (currency pair, date, base/quote) are expected, so it fails to compensate for the coverage gap.

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

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

The description only restates the HTTP path and title ('GET /api/accounting/fx/spot-rate'), so an agent can infer it fetches a foreign-exchange spot rate, but it never says in prose what it does or returns. No sibling differentiation is offered beyond the URL fragment, and the duplicated second sentence adds nothing.

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

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

There is no statement of when to use this tool versus alternatives such as describe_operation, search_operations, or execute_read. The only directional hint is a pointer to describe_operation for 'native request schemas', which is a schema-lookup instruction, not usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered and the description adds no behavioral context of its own. It says nothing about what a connection id must reference, what the response contains, or what happens if the connection has no intercompany mode configured.

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

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

The single sentence is duplicated verbatim, which is pure waste rather than concision. The only content-bearing clause (the describe_operation pointer) is buried at the end instead of 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?

For a tool with no output schema, a nested 'query' object, and 0% schema description coverage, the description should explain the id semantics and the returned mode value. Instead it repeats the path and defers entirely to describe_operation, leaving the agent to open a second tool just to learn the request shape.

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

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

Schema description coverage is 0% and the description supplies no meaning for either parameter. The literal ':id' in the path implies a connection identifier, but the schema's required 'id' (minLength 1, maxLength 2000) and the free-form 'query' object are left entirely unexplained.

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 is the URL path repeated verbatim, so the purpose must be reverse-engineered from 'connections/:id/intercompany-mode'. It never states in plain language that it retrieves the intercompany-mode setting for a given accounting integration connection, and the sibling set contains several near-identical connections endpoints it does not distinguish itself from.

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

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

No when-to-use guidance is given. The only routing hint is 'describe_operation provides native request schemas', which points at a helper for schema lookup rather than explaining when this endpoint should be chosen over the four other get_accounting_integration_connections_* 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered elsewhere. The description adds nothing beyond the path—no return shape, pagination, filtering, or auth context—so it contributes no behavioral value.

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

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

Extremely short, but the same path sentence is duplicated verbatim, which is pure waste rather than conciseness. The one useful pointer (describe_operation) is buried at the end behind the repetition.

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

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

For a list-style GET endpoint with an undocumented free-form query object and no output schema, the description omits any explanation of what is returned or how to scope results. An agent could not call this correctly without falling back to describe_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?

Two parameters (a free-form 'query' object and an empty 'params' object) exist with 0% schema description coverage, and nested objects are involved. The description supplies no parameter meaning at all, leaving the agent to guess how to pass filters.

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 is just the raw URL path repeated twice, so the only signal is that it touches 'accounting-integration/connections'. It does not say whether this lists connections, retrieves a single connection, or how it differs from the five sibling get_accounting_integration_connections_* 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 only actionable sentence points the agent to describe_operation for native request schemas, which is a retrieval hint rather than a when-to-use rule. There is no guidance on choosing among the many near-identical connections and integration 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds nothing on top — no mention of pagination, what a 'dimension' record contains, error behavior for a missing id, or scoping to the workspace. It does not contradict the annotations, but it contributes zero behavioral context.

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

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

Very short, but the first sentence is duplicated verbatim, which is pure waste rather than concision. There is no front-loaded statement of purpose — the reader hits a URL path and a hex operation ID before any meaning.

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

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

No output schema exists, a nested 'params' object is required, and 0% of parameters are documented anywhere — yet the description supplies none of the missing information about the response shape or the required identifier. For a nested-object lookup tool this leaves the agent unable to call it confidently.

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

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

Schema description coverage is 0% across two parameters: the required nested 'params.id' (a bare string with only length constraints) and the free-form 'query' object with additionalProperties. The description never mentions either; the ':id' placeholder in the URL is the only clue that it identifies a connection, and 'query' is entirely unexplained.

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 is literally the tool title repeated twice: a raw REST path 'GET /api/accounting-integration/connections/:id/dimensions' with no plain-language statement of what the operation returns. An agent can infer 'fetch dimensions for a connection' only by parsing the URL, and it cannot distinguish this from the many sibling get_accounting_integration_connections_* tools, which are also raw-path restatements.

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

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

There is no statement of when to use this versus siblings such as get_accounting_financial_dimensions_by__ or the other connection sub-resource tools. The only actionable hint is the trailing note that 'describe_operation provides native request schemas', which at least points the agent at a prerequisite tool for schema detail, but no use/exclude conditions are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is known. The description adds nothing beyond that - no mention of what the mapping represents, whether it is paginated, or what the response contains, despite being an integration-configuration read.

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 same path sentence is repeated verbatim, which is pure waste, and the operation-ID boilerplate occupies a third of the text. It is short but badly structured, with no front-loaded explanation of purpose.

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 0% parameter documentation, no output schema, and a nested free-form query object, the description should carry substantial weight. Instead it supplies only a path, leaving the agent unable to tell what data comes back or how to scope the request.

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

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

Schema description coverage is 0% for two parameters (query and params.id), and the description only echoes ':id' from the path. It never explains that id is a connection identifier or what the free-form query object accepts, so it fails to compensate for the completely undocumented 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 merely restates the HTTP verb and path from the title, with no explanation of what a 'dimension-slot-mapping' resource is or what the endpoint retrieves. An agent learns nothing it did not already get from the name/title combination.

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

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

There is no guidance on when to call this versus the many sibling connection endpoints, or what the prerequisite state is. The only actionable hint is that describe_operation exposes native request schemas, which is a tooling note rather than usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered elsewhere. The description adds nothing beyond that — no note on rate limits, pagination, empty-connection behavior, or what the accounts payload represents.

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 same sentence is duplicated verbatim, which is pure waste, and the remaining content is a machine-generated operation ID plus a redirect. Nothing is front-loaded in human-readable 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?

No output schema, no parameter documentation, no behavioral notes; for a nested-parameter read endpoint the only substantive content is a pointer to another tool. An agent cannot form a request or judge relevance without calling describe_operation first.

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

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

Schema description coverage is 0%, so the description must compensate, and it does not: the required 'id' (connection id) and the free-form 'query' object are never described. The ':id' in the path hints at the connection identifier, but there is no guidance on accepted query filters.

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 REST path does convey a verb (GET) and a concrete resource (accounts belonging to one integration connection), so an agent can roughly infer intent. But it is stated only as a URL, with no plain-language explanation of what 'accounts' are (e.g. chart-of-accounts records pulled from the connected accounting system) and no differentiation from the dozens of sibling get_accounting_integration_connections_* 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?

No when-to-use, when-not-to-use, or alternative is given. The only guidance is a pointer that 'describe_operation provides native request schemas', which helps with request construction but not with tool selection among the many near-identically named 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that: no statement of what is returned, whether results are scoped to a single connection, or any auth/size caveats.

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 only substantive content is the identical REST path repeated twice, which is pure redundancy. The remaining clause about describe_operation is useful but is buried in boilerplate rather than 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?

With zero parameter documentation, no output schema, and nested query objects in the input, the description leaves an agent unable to predict the response shape or the meaning of the free-form query bag. For a read endpoint with no output schema, the description needed to do far more of the explanatory work.

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

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

Schema description coverage is 0% across two parameters, so the description must compensate and it does not. The path template weakly implies that params.id is the connection id, but the free-form 'query' object and its allowed keys are never explained anywhere.

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 verb (GET) and a resource path ending in 'dimension-slot-definitions' scoped to an accounting-integration connection, so the raw operation is identifiable. But it is a verbatim REST path rather than a plain-language statement of what dimension slot definitions are, and it is indistinguishable from the many other get_accounting_integration_connections__* siblings that share the same prefix.

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

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

There is no guidance on when to call this versus siblings such as describe_operation, execute_read, or the other connection sub-resource GETs. The only routing hint, 'describe_operation provides native request schemas,' is about fetching a schema, not about when this tool is the right choice.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false, so the safety profile is fully covered by structured data. The description adds no behavioral context such as scoping, filtering requirements, or pagination, so it contributes nothing beyond the annotations.

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?

Very short, but the content is a duplicated URL string rather than front-loaded meaning; the repetition wastes the entire budget without conveying anything useful.

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

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

For a tool with a nested free-form query object, zero parameter documentation, and no output schema, the description supplies none of the context an agent needs to invoke it correctly, and it does not explain the relationship to the sibling module-field tool.

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

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

Schema description coverage is 0% and the description says nothing about the two parameters. The free-form 'query' object (additionalProperties: {}) is entirely undocumented, leaving the agent to guess what query keys are accepted.

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 only repeats the raw endpoint path 'GET /api/accounting-integration/module-fields' twice, which restates the title rather than explaining what a module field is or which module's fields are returned. An agent cannot distinguish this from the near-identical sibling get_accounting_integration_module_field_54b26c135c8bbb56776effa3.

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

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

No when-to-use or when-not-to-use guidance is given, and no alternative is named. The only actionable pointer is that 'describe_operation provides native request schemas', which hints at a discovery workflow but says nothing about selecting this tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so safety is fully covered elsewhere. The description adds nothing about response shape, pagination, or scoping rules, only a pointer to describe_operation for schemas.

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?

Very short, but the sole content sentence is duplicated word-for-word, so a third of the text is pure waste. The operation ID and describe_operation pointer are the only non-redundant content.

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

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

A tool with an undocumented required param, a free-form nested query object, and no output schema needs more than a restated path. An agent cannot tell what values 'module' accepts or what the response contains.

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

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

Schema description coverage is 0% and the description never explains the required 'module' path parameter or the free-form 'query' object. With two parameters and no schema documentation, the description should compensate but supplies nothing.

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 repeats the HTTP path twice and adds nothing about what a 'module field' is or what set of records is returned. It restates the title verbatim, making it close to tautology, though the path does at least indicate a GET on a module-scoped resource.

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

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

No indication of when to call this versus the near-identical sibling get_accounting_integration_module_field_4d5cadee1442775f9d9fd558 or describe_operation/execute_read. The only guidance is a pointer that describe_operation holds native schemas, which is not a usage condition.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety is covered externally; the description adds essentially nothing beyond that. It does not disclose that an authorize endpoint typically initiates an external OAuth handshake or what it returns, which is the key behavioral fact an agent would need.

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

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

The single meaningful sentence is duplicated verbatim, wasting half the description, and the remaining text is an operation ID plus a meta-instruction. Nothing is front-loaded about the actual action.

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

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

With no output schema and no behavioral notes, an agent has no idea whether this returns a URL, a token, a redirect, or a connection object, nor whether it mutates external state. For an OAuth authorization endpoint in a large tool catalog, the description is materially incomplete.

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

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

Schema description coverage is 0% and the input schema is a generic object with an untyped 'query' bag and an empty 'params' object, so the description carries the full burden — yet it says nothing about what query parameters exist or are needed. Pointing at describe_operation defers rather than compensates.

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 only repeats the raw path 'GET /api/accounting-integration/quickbooks/authorize' twice, which merely restates the title. It never says what the endpoint actually does (start a QuickBooks OAuth authorization flow, return a redirect/auth URL, etc.), so an agent cannot distinguish it from the sibling get_accounting_integration_xero_authori tool beyond the vendor name.

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

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

The only routing hint is that describe_operation provides native request schemas, which is about schema discovery rather than when to call this versus the Xero authorize endpoint or describe_operation itself. No prerequisites (e.g., admin role, existing integration config) or exclusions are stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds only the mildly useful note that describe_operation supplies the native request schema, but says nothing about result shape, pagination, or auth scope. With annotations carrying the behavioral load, a 3 is right.

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 first two sentences are identical copies of the endpoint path, so one of them is pure waste. The remaining operation-ID sentence earns its place, but the definition is padded by duplication rather than front-loaded with useful information.

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

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

For a tool with nested objects, zero schema description coverage, and no output schema, the description leaves an agent unable to construct a correct call without consulting describe_operation. It acknowledges that dependency but supplies no configuration of its own.

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

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

Schema coverage is 0% and the two parameters (a free-form 'query' object and an empty 'params' object) are entirely undocumented in both schema and description. The single compensating signal is the referral to describe_operation for native request schemas, which is a partial but real mitigation rather than meaningful semantic detail.

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

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

The description is the raw route string 'GET /api/accounting-integration/sftp-configs' repeated verbatim twice, which only restates the name and title rather than explaining what the operation returns or how it differs from siblings like the integration connection or sync job getters. A reader can infer it reads SFTP configuration, but nothing more specific.

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

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

There is no when-to-use guidance, no preconditions, and no comparison against alternative tools. The only directive is 'describe_operation provides native request schemas', which is a pointer for schema discovery, not usage 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered by structured data. The description adds nothing beyond that — no note on what a sync job record contains, whether not-found is possible, or how the response is shaped. No contradiction with annotations.

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?

Brevity is not a virtue here: the same endpoint sentence appears twice in a row, which is pure waste, and what remains is an operation UUID plus a pointer to another tool. Only one of the three sentences carries any information.

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

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

For a nested-object, zero-described-parameter tool with no output schema, the description should explain the single-record retrieval semantics and the ID's meaning; instead it defers entirely to describe_operation. An agent must call a sibling tool to learn anything about the request shape.

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

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

Schema description coverage is 0% and the description does not compensate. The ':id' path token faintly maps to params.id, but nothing explains what the ID identifies, and the nested 'query' object parameter is left entirely undocumented in both schema and prose.

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 is the raw route string 'GET /api/accounting-integration/sync-jobs/:id' repeated verbatim twice, which only restates the name and title. It never says in plain language that it retrieves a single sync job record by ID, and it does nothing to separate it from the sibling list tool get_accounting_integration_sync_jobs_dc723bca47df10fef58c8b23.

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

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

No when-to-use guidance, no prerequisites, and no mention of when the sibling list endpoint or describe_operation should be preferred. The only actionable hint is 'describe_operation provides native request schemas', which is a discovery pointer rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered; the description adds nothing on top. It says nothing about pagination, result caps, ordering, or what the sync-job records contain — all relevant for a collection endpoint.

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

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

The description is short, but it wastes its entire length repeating the identical path string twice. That duplication displaces any substantive content rather than making the definition 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 collection endpoint with an opaque nested 'query' parameter, no output schema, and no annotations gaps to fall back on, the description should explain filtering/paging and result shape. The describe_operation pointer is the only genuinely useful element, leaving the definition materially incomplete.

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

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

Schema description coverage is 0% and the single meaningful parameter ('query') is an untyped free-form object with additionalProperties {}, so the schema conveys no semantics at all. The description's only help is telling the agent to call describe_operation for native request schemas, which is a useful pointer but does not itself explain any accepted keys or values.

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

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

The description only restates the HTTP verb and path ('GET /api/accounting-integration/sync-jobs') twice, mirroring the title without added explanation. It never clarifies what a 'sync job' is or how this list endpoint differs from the sibling get_accounting_integration_sync_jobs_by_... endpoint, so an agent cannot disambiguate from the name alone.

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

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

There is no statement of when to use this list endpoint versus the by-ID sibling, nor any precondition, pagination, or filtering context. The only routing hint is the pointer to describe_operation, which addresses schema lookup rather than tool 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?

Annotations already declare readOnlyHint/idempotentHint/non-destructive, so the safety profile is covered, but the description adds nothing beyond that. For an authorize endpoint the agent needs to know whether it returns a redirect/consent URL, whether it creates server-side state, or what errors occur if Xero isn't configured — none of which is disclosed.

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

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

The first sentence is duplicated verbatim, wasting the only substantive line of the description. Length is short but the content is filler rather than front-loaded 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?

With no output schema, no parameter documentation, and no behavioral explanation beyond annotations, an agent has essentially no basis for calling this correctly — it cannot tell what the free-form query accepts or what the call returns.

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

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

Two parameters (`query` and `params`) have 0% schema description coverage, and the description provides no parameter information at all. The free-form `query` object in particular is left entirely unexplained, so there is nothing to compensate for the coverage gap.

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

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

The description only restates the HTTP path and title verbatim ('GET /api/accounting-integration/xero/authorize'), which is a tautology of the name/title. It never explains what an 'authorize' call actually does (e.g. start a Xero OAuth flow, return a consent URL), and it does not distinguish this tool from the many sibling `get_accounting_integration_*` endpoints.

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

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

No when-to-use or when-not-to-use guidance is given. The only actionable sentence points the agent at `describe_operation` for native request schemas, which is a discovery hint rather than usage criteria; the agent must still guess whether this starts an OAuth handshake or returns existing authorization state.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds zero behavioral context — no mention of pagination, filtering scope, or what the template list contains — so it contributes nothing beyond structured data.

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 first sentence is duplicated verbatim, wasting half the text, and the content is front-loaded with a machine path rather than a human-readable purpose. It is short but by omission, not by efficiency.

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 2 undocumented params, no output schema, and nested objects in the schema, the description should carry meaningful load but instead defers entirely to describe_operation. An agent cannot confidently call this tool from the definition alone.

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

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

Schema description coverage is 0% and both parameters (query, params) are opaque generic catch-alls. The description offers no parameter meaning at all, only a pointer to describe_operation, which pushes the agent to another tool call rather than adding 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 is essentially the URL path restated twice plus an operation ID, which only implicitly tells an agent this lists journal-entry templates. There is no plain-language verb+resource statement, and nothing distinguishes it from siblings such as get_journal_entries_* or get_templates_leases.

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

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

No when-to-use guidance is given beyond an implicit redirect: 'describe_operation provides native request schemas.' It doesn't say what this endpoint returns versus the journal-close or journal-entry siblings, nor any preconditions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. Beyond that the description adds nothing: no indication of what the response body contains, whether it returns workspace-level or company-level configuration, or whether any query parameters change 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?

The single substantive sentence is duplicated verbatim ('GET /api/...' appears twice), which is pure waste, and the front-loaded content is a raw URL path rather than a human-readable statement of purpose.

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 endpoint with two undocumented parameters, no output schema, and deep nesting hints, the description should at minimum say what configuration object is returned and what the query object can carry. Neither is present, leaving the agent to infer everything from the slug and a redirect to another tool.

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

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

Schema description coverage is 0% for two opaque parameters ('query' as a free-form object and an empty 'params' object), so the description carries the burden and fails. The lone note that describe_operation provides native request schemas is a pointer, not documentation of what query keys or params this endpoint accepts.

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 only repeats the URL path 'GET /api/accounting/journal-close/account-number-format' twice, which restates the name and title rather than explaining in plain language what the tool returns (e.g. the configured journal-close account number format/mask). An agent learns nothing about the resource beyond guessing from the slug, and nothing distinguishes it from the ~40 other journal-close siblings.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternatives named among the many journal-close endpoints. The only steering is a pointer to describe_operation for native request schemas, which is a schema-retrieval hint rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description contributes nothing beyond that — no note on scoping, required permissions, pagination, or what the aggregation covers.

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 same endpoint sentence appears twice back-to-back, which is pure waste rather than front-loaded signal. The remaining clause about describe_operation is the only informative content and could have stood alone.

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 opaque, untyped aggregation endpoint with nested free-form query objects, no output schema, and 0% parameter documentation, the description should explain what is aggregated and what filters exist. Instead it offers only an operation ID and a pointer to a sibling, leaving the essential contract undefined.

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

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

Schema description coverage is 0% for two free-form parameters ('query' accepting arbitrary properties and an empty 'params' object), so the schema provides almost no meaning. The description makes no attempt to describe accepted query fields or filters, only deferring to describe_operation, leaving the caller with no semantic anchor.

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 repeats the URL path 'GET /api/accounting/journal-close/aggregation' twice and adds only an operation ID, which is a tautological restatement of the name and title. It never says in plain language what a 'journal close aggregation' returns (e.g. aggregated close status, balances, or rollups) or how it differs from the many sibling journal-close endpoints such as get_accounting_journal_close_batches or get_accounting_journal_close_runs.

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

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

No when-to-use, when-not-to-use, or sibling comparison is given. The only guidance is a pointer to describe_operation for request schemas, and a generic reference to execute_read is absent entirely, so an agent must infer that this is a read call routed through some other tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that (no pagination, filter semantics, or authentication context), so it contributes no behavioral value.

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

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

The single repeated sentence is redundant waste, and the operation-ID/metadata boilerplate is not front-loaded with any useful information. Brevity here reflects under-specification rather than efficiency.

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, 0% parameter documentation, and nested-object inputs, the description provides no guidance on filtering, pagination, or response shape. It is wholly inadequate for calling 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?

There are two parameters (query, params) with 0% schema description coverage and nested objects, yet the description says nothing about what may be passed in query or params. It entirely fails to compensate for the schema gap.

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

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

The description only restates the tool title/path twice ("GET /api/accounting/journal-close/batches") without saying what a "journal close batch" is or what listing them returns. With many sibling journal-close tools (runs, profiles, setups, catalog), an agent cannot distinguish this tool from them based on the description.

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

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

The only guidance is that "describe_operation provides native request schemas," which points to a meta tool rather than explaining when to use this endpoint vs. siblings like get_accounting_journal_close_runs or get_accounting_journal_close_catalog. No when-to-use, no exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, covering the safety profile. The description adds nothing beyond that—no indication of what the catalog returns, whether it is user-scoped, or any pagination/auth behavior—so it contributes no behavioral context of its own.

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

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

The description wastes its length by repeating the identical endpoint string twice and appending an opaque operation ID, while omitting any actual explanatory content. Not under-specified for lack of space, but structurally redundant.

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

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

With no output schema, 0% schema coverage, and a nested free-form 'query' object, the description should explain what is returned and what query supports. It provides none of that, so an agent cannot confidently invoke this tool without first calling describe_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 0% and the two parameters ('query' as a free-form object and an empty 'params' object) are entirely undocumented. The description says nothing about what query keys are accepted or what they filter, leaving the agent with no usable 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 is just the endpoint path 'GET /api/accounting/journal-close/catalog' repeated twice, which restates the tool name/title rather than explaining what a journal-close catalog is or contains. An agent learns only that this is some GET on a journal-close catalog, with no differentiation from the many sibling journal-close endpoints.

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

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

The only guidance is 'describe_operation provides native request schemas', which tells the agent where to find parameter details but not when to use this endpoint versus siblings like get_accounting_journal_close_configurat_... or get_accounting_journal_close_profiles_.... No when-to-use or exclusion criteria are present.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds nothing — no note on what the context payload contains, scoping, or how it relates to a close run — so it fails to add value beyond structured 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?

Brief, but the only content is a duplicated path string, which is pure waste rather than front-loaded information. Under-specification, not conciseness.

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

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

With no output schema, 0% parameter documentation, and an opaque free-form query object, the description should carry the load and does not. An agent cannot call this correctly without further exploration.

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

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

Schema description coverage is 0% and there are two parameters, including a nested free-form 'query' object with arbitrary properties. The description provides no parameter meaning whatsoever, leaving the agent to guess at filter keys.

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 is just the endpoint path repeated verbatim twice, plus an operation ID. It never states what 'company-context' actually returns or how it differs from the many sibling journal-close context endpoints (catalog, batches, setups, workspace, configuration).

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

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

No when-to-use, when-not-to-use, or alternative routing is given beyond a pointer that describe_operation exposes native request schemas. An agent has no basis for preferring this over the other journal-close endpoints.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered by structured data. The description adds nothing about what settings are returned, scope (company vs workspace), or auth requirements beyond pointing to describe_operation.

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

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

Short, but the path is duplicated verbatim and the operation ID adds no decision value. It is under-informative rather than concise.

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

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

With 2 undocumented parameters, 0% schema coverage, and no output schema, the description should explain request shape and return content. It only defers to describe_operation, leaving real gaps for an agent that must call it blind.

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

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

Schema description coverage is 0% and the schema is a generic free-form 'query' object plus empty 'params'. The description makes no attempt to explain what those parameters accept, so an agent has no idea which query keys are valid.

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 only restates the endpoint path twice: 'GET /api/accounting/journal-close/company-settings.' It names a resource but adds no verb-level explanation of what the endpoint returns, and it is indistinguishable from a dozen sibling journal-close endpoints (company_co, configurat, catalog, setups). This is close to tautology against the title.

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

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

No guidance on when to call this versus the many other journal-close read endpoints. The only directive is 'describe_operation provides native request schemas,' which is a discovery hint, not usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and closed-world, so the safety profile is fully covered by structured data. The description adds nothing beyond that: no auth requirements, no note about what configuration scope is returned, no pagination or caching 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?

The definition is short but broken: the same endpoint path appears twice back-to-back, which is pure duplication rather than front-loaded content. The only other sentence contains an operation ID and a pointer, neither of which conveys operational meaning.

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

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

With no output schema, 0% schema description coverage, and no annotations-uncovered details in the text, the description is essentially a placeholder. An agent cannot tell what configuration values are returned or how to filter via the free-form query object.

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

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

Schema description coverage is 0% with two parameters (a free-form 'query' object and an empty 'params' object), and the description provides no parameter information at all. The agent gets no syntax, filtering, or naming guidance to compensate for the schema gap.

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

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

The description is a verbatim repetition of the endpoint path with no elaboration of what the configuration object contains or what 'journal close configuration' means. The path implies a GET on a resource, but it does nothing to distinguish this from the many sibling journal-close endpoints (catalog, setups, profiles, workspace, company_config).

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

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

The only guidance is a pointer that 'describe_operation provides native request schemas', which helps discovery but gives no when-to-use or when-not-to-use criteria. There is no routing to the many relevant sibling tools such as get_accounting_journal_close_setups_by_ or get_accounting_journal_close_company_co_.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description contributes nothing beyond that — no statement of what is returned, whether results are scoped to a workspace/period, pagination, or 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?

The description duplicates the identical URL sentence twice, which is pure waste, and the remaining content is a mechanical operation-ID string. There is no front-loaded explanation of purpose.

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 nested-object query endpoint with no output schema and no documented parameters, an agent needs meaning for the query filters and the shape of the response. The description provides neither, leaving only a pointer to describe_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 0% and there are two parameters (a free-form 'query' object with additionalProperties and an empty 'params' object). The description says nothing about what should go in 'query' — no filter keys, no date/period semantics — so it fails to compensate for the coverage gap.

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

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

The description only restates the tool name as a raw URL path ('GET /api/accounting/journal-close/dimension-sources') twice. It never explains what a 'dimension source' is or what the endpoint returns, so an agent cannot differentiate this from the sibling get_accounting_journal_close_dimension__fbf666ceb0ede2498b035498.

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

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

There is no when-to-use guidance and no named alternative among the many journal-close siblings. The only actionable pointer is the note that describe_operation provides native request schemas, which is a hint about schema discovery rather than about when this tool is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered structurally. The description adds no behavioral context of its own — no note on response shape, pagination, or what a "dimension source" is in this domain.

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 same path sentence appears twice back-to-back, which is pure waste, and the remaining sentence is a metadata pointer rather than substantive content. Nothing is front-loaded to tell an agent what the tool does.

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

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

No output schema and zero schema descriptions mean the description must carry the burden, yet it supplies neither purpose detail, module value semantics, nor the structure of the nested query object. An agent cannot confidently invoke this from the definition alone.

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

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

Schema description coverage is 0% across 2 parameters. The description only echoes ':module' from the path, giving no semantics for allowed module values, and says nothing about the arbitrary free-form 'query' object, leaving both parameters effectively undocumented.

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

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

The description is just the endpoint path repeated verbatim twice, plus an operation ID. The path does imply a read of dimension-source values for a given module, but there is no verb-level statement of what the tool returns and no differentiation from the similarly named sibling get_accounting_journal_close_dimension__eaf4ccfadc2e63425b7f3ace.

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

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

No statement of when to use this versus the many other journal-close endpoints. The only guidance is "describe_operation provides native request schemas", which points at how to discover the contract, not when this tool is the right call.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond the path and a pointer to describe_operation: no mention of scope, permissions, or what the payload contains.

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

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

It is short, but two of its three clauses are the identical URL path, which is pure waste. Content is not front-loaded with anything useful because there is nothing to front-load.

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

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

With a 0%-documented nested query object and no output schema, the description should explain accepted query keys and the shape of the response. It does neither, so an agent cannot call this correctly without first calling describe_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 0% and the free-form 'query' object accepts arbitrary keys with no documentation anywhere. The description provides no parameter meaning at all, leaving the agent to guess what filters or identifiers the endpoint accepts.

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 only restates the HTTP verb and path, and does so twice. It tells the agent this is a GET on journal-close integration-format, but never says what an 'integration format' is or what the endpoint returns, so it cannot be distinguished from the many sibling journal-close GETs beyond the URL slug.

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

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

There is no when-to-use or when-not-to-use guidance, and no comparison against siblings like get_accounting_journal_close_catalog or get_accounting_journal_close_configurat. The only actionable hint is the redirect to describe_operation for schemas, which is a schema pointer rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing behavioral beyond that — no indication of what data is returned, whether results are period-scoped, pagination, or required permissions. Its sole extra content is a referral to describe_operation.

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

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

Short, but the first sentence is duplicated verbatim — pure waste in an already minimal definition. The useful clause (operation ID plus the describe_operation pointer) is buried after the repetition rather than 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?

For a tool with a fully opaque nested query object, no output schema, and dozens of near-identically named journal-close siblings, the definition is far too thin to guide correct invocation. The describe_operation referral is the only bridge to the real contract, and it is not enough on its own.

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

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

Schema description coverage is 0% and the two parameters are an untyped free-form `query` object (additionalProperties: {}) and an empty `params` object. The description gives no parameter meaning at all; it only notes that describe_operation exposes the native request schemas, which partially mitigates the opacity but does not document anything itself.

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 text is the endpoint path repeated verbatim twice: "GET /api/accounting/journal-close/liability-presentation." It restates the name/title rather than explaining in plain language what a "liability presentation" for a journal close actually is or returns. An agent learns only the HTTP verb and URL slug, which is marginally more than the name alone.

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

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

There is no when-to-use guidance, no exclusions, and no differentiation from the many sibling journal-close endpoints (batches, aggregation, profiles, runs, unassigned, workspace). The only actionable pointer is that describe_operation supplies native request schemas, which is a parameter-discovery hint, not usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds essentially nothing beyond a pointer to describe_operation, giving no information about error behavior, what a baseline represents, or response shape.

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

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

The single sentence is duplicated verbatim, wasting half the text, and the remaining operation-ID/describe_operation note is boilerplate. No front-loaded explanation of the tool's effect.

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 0% schema coverage, no output schema, and a nested query object, the description is far too thin to let an agent call this correctly. Nothing explains what 'baseline' data is or what the untyped query parameters do.

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

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

Schema description coverage is 0% for both parameters, so the description would need to explain 'id' and the free-form 'query' object. It only implicitly shows ':id' in the path, leaving the query object and id format/constraints (maxLength 2000, string) undocumented.

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

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

The description only repeats the endpoint path 'GET /api/accounting/journal-close/profiles/:id/baseline' twice, with no natural-language explanation of what a 'baseline' profile is or what is returned. The path does imply a read of a baseline resource scoped to an id, but it adds nothing the title doesn't already state and gives no way to distinguish this tool from the many sibling get_accounting_journal_close_profiles_b_* variants.

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

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

No when-to-use guidance, no mention of alternatives such as describe_operation or the sibling profile tools, and no prerequisites. The agent is left to infer usage entirely from the URL.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds nothing beyond that — no note on what the review payload contains, whether it is computed on demand, or any scoping 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?

The core sentence is duplicated word-for-word with zero added information, and the remainder is an operation ID plus a pointer to another tool. Short, but the space is not earned — duplication is pure noise.

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, 0% parameter description coverage, and a nested free-form query object, the description should explain what the input-review response contains and how the query is used. It provides none of that, leaving the agent unable to use the tool confidently beyond the bare minimum.

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

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

Schema description coverage is 0% for two parameters. The path string conveys that :id identifies a profile, but the free-form 'query' object (additionalProperties: {}) has no documented meaning anywhere in the description or schema, and :id's expected format is not clarified beyond minLength/maxLength.

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 is the raw endpoint path repeated twice verbatim, which merely restates the tool name and title without explaining in plain language what an 'input review' for a journal close profile is or what it returns. An agent learns only that it is a GET on an :id-scoped sub-resource.

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

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

There is no guidance on when to use this tool versus the many sibling journal-close endpoints (batches, runs, setups, workspace, catalog). The only actionable sentence points to describe_operation for request schemas, which is a schema hint rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds nothing behavioral beyond that — no note on 404 behavior for a missing id, no auth/scope requirements, no pagination or return-shape hints. The describe_operation pointer is the sole marginal contribution.

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?

Short, but the first sentence is duplicated verbatim, which is pure waste rather than concision. The operation ID and the describe_operation pointer are buried in a trailing clause rather than front-loaded as the actionable instruction.

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 nested-parameter, 2-arg retrieval endpoint with no output schema and 0% schema description coverage, the description should at minimum explain the id and what is returned. It supplies neither, relying entirely on a redirect to describe_operation, so an agent cannot call this correctly from the definition alone.

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

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

Schema description coverage is 0%, and the description never mentions the required 'id' path parameter or the optional 'query' object. The single sentence 'describe_operation provides native request schemas' acknowledges that schemas live elsewhere but doesn't convey any parameter meaning (format, source of the id, allowed query keys), leaving the agent to guess.

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 is essentially a restatement of the tool name and URL path with no added meaning: 'GET /api/accounting/journal-close/profiles/:id' appears verbatim twice. It implies a retrieve-by-id of a journal close profile, but doesn't say what a 'profile' is or how it differs from the many sibling journal-close profile tools (three similarly-named profile endpoints).

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

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

No when-to-use or when-not-to-use guidance, and no discrimination against the closely-named siblings get_accounting_journal_close_profiles_b_529dea..., _9a1da6..., or get_profile. The only actionable pointer is the generic 'describe_operation provides native request schemas', which is a discovery hint rather than usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered structurally. The description adds nothing behavioral beyond that — no note on pagination, filters, default ordering, or what the run list contains.

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

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

It is short, but the sentence is duplicated identically and the remainder is a raw operation ID and a pointer. No useful information is front-loaded, so brevity here reflects under-specification rather than efficiency.

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, zero parameter coverage, and no behavioral notes, the description leaves an agent unable to determine how to call or interpret this endpoint. It does not meet the burden for a 2-parameter, nested-object list tool.

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

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

Schema description coverage is 0% and there are two parameters (a free-form query object and an empty params object). The description provides no parameter meaning, accepted query keys, or format, so an agent gets nothing from the text.

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

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

The description just repeats the raw endpoint path verbatim, twice. The path does reveal the resource (journal close runs), but no natural-language verb or scope is given, so it essentially restates the title/name rather than explaining the operation.

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

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

There is no when-to-use guidance and no mention of alternatives among the many journal-close siblings (e.g., the by-id run endpoints or batches). The only hint is that describe_operation provides native request schemas, which is a tooling pointer, not usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered structurally. The description adds no behavioral context of its own — nothing about what the run record contains, error behavior for an unknown id, required permissions, or scoping to a workspace/company.

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

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

The single substantive sentence is duplicated verbatim, and the opaque hex operation ID plus a pointer to describe_operation consume much of the text without informing tool selection. Short, but the content is noise rather than front-loaded signal.

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, a nested query object, and 0% parameter documentation, the description should at minimum explain the run resource and the id's meaning. It does neither, so an agent cannot predict the return shape or confidently construct the query parameter.

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

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

Schema description coverage is 0% for 2 parameters, so the description carries the burden and does not meet it. The only information conveyed is the ':id' path template, which implies params.id identifies a run; the 'query' object parameter is completely unexplained in both the schema and the 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 restates the tool name and HTTP path verbatim ('GET /api/accounting/journal-close/runs/:id') without saying what a journal close run is or what the response represents. It technically indicates a read-by-ID operation, but adds nothing beyond the title, and does not distinguish this tool from the several sibling tools with identical 'journal_close_runs_by_id' names.

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

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

There is no when-to-use guidance, no exclusions, and no pointer to alternatives such as get_accounting_journal_close_runs_110a7b0396175f5089714eca (the list endpoint). The only routing hint is 'describe_operation provides native request schemas', which concerns parameter discovery rather than tool 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered structurally. The description adds nothing beyond the endpoint path plus a pointer to describe_operation - no disclosure of what 'activity' returns, pagination, or filtering 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?

The one meaningful sentence is duplicated verbatim, wasting the entire body of the description, and no information is front-loaded beyond the raw route.

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

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

With no output schema and 0% schema coverage on both parameters, the description would need to explain the run-activity payload and query filters to be usable. It provides neither, delegating everything to describe_operation without telling the agent when that delegation is warranted.

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

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

Schema description coverage is 0%, with an `id` path param and an untyped `query` object, so the description must compensate and does not. The ':id' in the path hints that id is the run identifier, but nothing explains accepted query parameters or constraints (maxLength 2000).

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 is essentially the endpoint path restated twice, so the resource (journal-close run activity for a given id) is inferable only by decoding the URL. It offers no verb-level description of what the 'activity' payload contains and does nothing to distinguish it from the many sibling journal-close runs endpoints.

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

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

The only guidance is the pointer that 'describe_operation provides native request schemas', which vaguely indicates an alternative tool for schema lookup. There is no statement of when to call this vs. the numerous sibling run endpoints (batches, profiles, unassigned, workspaces) or what preconditions apply.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is fully covered. The description contributes nothing beyond that: no indication of what the 'status' payload represents, no auth/scope requirements, no note on what happens for a run in an invalid state.

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

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

It is short, but the single sentence is duplicated verbatim, so half the text is pure waste. There is no front-loaded plain-language statement of purpose, just a raw HTTP path.

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

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

A read tool with no output schema needs the description to say what comes back (run status, current stage, completion state). Here the description is functionally a generated route stub plus a pointer to describe_operation; an agent has no idea what the response looks like or how it differs from the four sibling run-status/run-detail tools.

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

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

Schema description coverage is 0% across 2 parameters. The path template ':id' at least lets an agent map params.id to the journal close run identifier, which is the one piece of meaning added. The 'query' object (additionalProperties: {}) is left entirely unexplained in both 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 is a restatement of the endpoint path 'GET /api/accounting/journal-close/runs/:id/status', from which an agent can infer it retrieves the status of a journal close run by ID. However, it never says so in plain language and does nothing to distinguish it from the several sibling tools named get_accounting_journal_close_runs_by_id_196eafa..., _3a80565..., _e033511..., which likely hit adjacent sub-resources of the same run.

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

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

No statement of when to prefer this tool over the sibling journal-close run endpoints. The only routing hint is that 'describe_operation provides native request schemas', which points to a metadata tool, not to usage conditions 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds nothing beyond that — no hint about what reconciliation payload contains, whether it is a snapshot vs live computation, or any scoping/auth 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 same URL sentence is printed twice back-to-back, which is pure duplication, and the remaining sentence is a boilerplate pointer. There is no front-loaded purpose statement, so the little content present is not efficiently structured.

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

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

No output schema exists, so the description should at least characterize the returned reconciliation data; it does not. With zero parameter documentation and four sibling tools with nearly identical names, the definition leaves an agent unable to confidently choose or correctly call it.

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

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

Schema description coverage is 0% for two parameters (required 'id' plus a free-form 'query' object). The description only embeds ':id' in the URL template, implicitly tying the id param to the path, and says nothing about the 'query' bag or id format/constraints (maxLength 2000). This does not compensate for the coverage gap.

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

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

The description is a verbatim repeat of the title/URL path ('GET /api/accounting/journal-close/runs/:id/reconciliation'), which restates the name rather than explaining in plain language what the call returns. An agent can infer 'fetch reconciliation for a journal close run', but nothing distinguishes it from the many sibling runs-by-id endpoints (e.g. get_accounting_journal_close_runs_by_id_196eafa1..., _3a80565f..., _d11e1e1a...).

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

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

No when-to-use or when-not-to-use guidance is given. The only actionable pointer is 'describe_operation provides native request schemas', which is a schema-discovery hint, not a routing rule between this and the several near-identical journal-close runs 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed-world scope, so the safety profile is covered. The description adds nothing beyond that: no pagination behavior, no ordering of versions, no note on what happens if the setup id doesn't exist, and no return shape.

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 padded: the identical endpoint path is printed twice, and the second copy carries no new information. The only substantive sentence is a pointer to describe_operation, so the space is not well spent.

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

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

No output schema exists and nothing in the description explains what the versions list contains or how it is shaped, which matters for a nested-object tool. Combined with an undocumented query parameter, an agent has to fall back on describe_operation for anything beyond the raw URL.

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

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

Schema description coverage is 0%, so the description must compensate and it does not. The ':id' is only visible as a URL placeholder with no statement that it is the journal-close setup identifier, and the free-form 'query' object parameter is entirely unaddressed in the 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 restates the endpoint path 'GET /api/accounting/journal-close/setups/:id/versions', which does convey a verb (retrieve) and resource (versions of a journal-close setup). However, it never explains in plain language what a 'version' is here, and it does nothing to distinguish this from the many other journal-close siblings such as get_accounting_journal_close_profiles_* or get_accounting_journal_close_runs_by_id_*.

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

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

There is no guidance on when to call this versus alternatives. The only pointer is 'describe_operation provides native request schemas', which redirects to a schema helper rather than explaining selection criteria. No prerequisites, no exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is fully covered by structured data. The description contributes nothing beyond that — no mention of what the response contains, whether it is scoped to a period, or what 'unassigned' implies.

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 endpoint path is duplicated verbatim in consecutive sentences, which is waste rather than conciseness. The operation ID and describe_operation pointer are the only non-redundant content.

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

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

No output schema exists, so the description carries the burden of describing the return shape, and it does not. Combined with a 0%-documented parameter schema and a vague resource noun ('unassigned'), an agent cannot confidently call or interpret this tool.

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

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

Schema description coverage is 0% and the description says nothing about the two parameters (an open-ended 'query' object and an empty 'params' object). For an endpoint whose only filtering mechanism is an untyped query blob, the description should explain accepted query keys, and it does not.

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 only repeats the raw endpoint path twice; it restates the title rather than explaining what 'unassigned leases' means in a journal-close context. An agent gets a resource path but no semantics to distinguish this from the dozens of sibling journal-close GET tools (batches, runs, profiles, setups).

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

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

No when-to-use, when-not-to-use, or alternative guidance is given. The only actionable hint is the pointer to describe_operation for native request schemas, which is a meta-instruction rather than usage context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds nothing beyond a pointer to describe_operation — no indication of what the workspace response contains, whether it is per-entity/per-period scoped, or how large it may be.

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 first sentence is duplicated verbatim, wasting half the text, and the remaining content is a technical identifier plus a meta-instruction. Nothing is front-loaded in terms of useful meaning.

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

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

With no output schema, an undocumented free-form query parameter, and a nested 'query' object, the description leaves the agent unable to construct a correct call without first invoking describe_operation. It is not adequate for the tool's complexity.

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

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

Schema description coverage is 0% and there are two parameters (a free-form 'query' object and an empty 'params' object). The description says nothing about either, so an agent has no idea what query keys are accepted — exactly the case where the description is required to compensate.

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 is essentially the raw endpoint path repeated twice, so it names a resource ('journal-close/workspace') and an HTTP verb, but never explains what a 'workspace' is or what data comes back. It offers no differentiation from close-related siblings such as get_accounting_journal_close_batches or get_accounting_journal_close_profiles.

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

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

No when-to-use or when-not-to-use guidance is given. The only routing hint is 'describe_operation provides native request schemas,' which tells the agent how to get more info rather than when to pick this tool over its many 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and closed-world scope, so the safety profile is covered. The description adds nothing beyond that: no mention of what an approval trail contains, whether entries are ordered, paginated, or empty for unapproved journals.

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 first sentence is repeated verbatim, which is pure waste, and the useful content (operation ID, schema pointer) is buried after it. Nothing is front-loaded in human-readable 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?

No output schema, no annotation-level detail about the response, and no description of the returned approval trail. For a nested-object, two-parameter retrieval endpoint, an agent would need to fall back entirely on describe_operation to call this 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 0%, so the description carries the burden and fails to meet it. The path implies 'id' is a journal entry identifier, which is a small gain, but the 'query' object parameter is never explained and no format, constraint, or expected value is given.

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 endpoint path does encode a specific verb+resource (GET the approval trail of a journal entry identified by :id), so an agent can infer the purpose. But the description only restates the URL twice and never says it in plain language, nor does it distinguish this from siblings like get_approvals_by_id or get_journal_entries_by_id.

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

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

There is no when-to-use or when-not-to-use guidance, and no indication of how this relates to the other approval and journal-entry tools. The only actionable hint is that describe_operation exposes native request schemas, which is a schema-discovery note rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds no behavioral context of its own beyond noting that schemas live in describe_operation; it does not contradict the annotations.

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 same URL sentence appears twice, which is pure duplication rather than conciseness. There is nothing front-loaded beyond the path, so the repeated sentence wastes space without adding meaning.

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

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

For a tool with a free-form query object, no output schema, and no documented return values, the description supplies none of the information an agent would need to invoke it correctly. It is effectively a bare endpoint stub.

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

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

Schema description coverage is 0% and there are two parameters, including a free-form 'query' object with additionalProperties and an empty 'params' object. The description provides no information about what query keys are accepted or what they filter, leaving both parameters entirely undocumented.

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

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

The description only repeats the raw URL path 'GET /api/accounting/journal-entries/true-up/configuration' twice. It names a resource and HTTP verb, but never explains in plain terms what a 'true-up configuration' is or what the call returns, so an agent must infer purpose purely from the path string.

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

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

There is no statement of when to use this endpoint versus siblings such as get_journal_entries or describe_operation. The only procedural hint is that 'describe_operation provides native request schemas,' which is a discovery pointer, not usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, and 'without changing anything' merely restates that. The description does add value by enumerating the aggregate contents (setup, rent schedules, options, readiness) and giving the underlying route, but says nothing about payload size, pagination, or errors.

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; the substantive content comes first and the route/operation-id metadata trails it. No filler, though the operation-id sentence is utility metadata rather than 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?

With no output schema, listing the sections returned is genuinely helpful, and the note that describe_operation carries native request schemas is useful. Still, the undocumented 'query' parameter and lack of any return-shape detail leave gaps for a nested-object read tool.

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

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

Schema description coverage is 0%, so the description must carry the burden. It only conveys lease id via the ':id' path template; the generic 'query' object is not explained at all, leaving half the parameters undocumented anywhere.

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 (inspect) plus the concrete resources returned: accounting setup, rent schedules, options, and measurement readiness, scoped to a lease by id. This distinguishes it from narrower siblings such as the dedicated rent-schedule or measurement endpoints, though it never names those siblings explicitly.

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

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

The phrase 'without changing anything' implies this is the safe read path, and the listed payload hints at when an agent would want it (checking measurement readiness before posting). But there is no explicit when-to-use/when-not guidance and no pointer to the parallel per-topic endpoints an agent might prefer.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds essentially nothing beyond pointing at describe_operation: no note on pagination, error behavior, permission needs, or what the accounting-profiles payload contains.

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

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

The first sentence is duplicated, which wastes the front-loaded position on redundancy rather than on what the tool returns. The trailing operation-ID boilerplate is machine metadata rather than guidance.

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

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

For a read endpoint with a nested free-form query object and no output schema, the agent needs at least the shape of the returned accounting profiles and how query parameters are forwarded. Neither is present; the description is barely above the endpoint signature alone.

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

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

Schema description coverage is 0% for two parameters: the required lease id and an unconstrained free-form query object. The description supplies no meaning for either, not even that id is the lease identifier, leaving the agent to infer everything from the path template.

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 is the URL path repeated verbatim twice, so the purpose can only be inferred from the endpoint string (retrieve accounting profiles for a lease id). It offers no differentiation from the three other get_accounting_leases_by_id_accounting__* siblings, which are indistinguishable by their hashed names.

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

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

There is no statement of when to use this tool, when not to, or which sibling to prefer. The only actionable direction is a pointer to describe_operation for request schemas, which is a discovery hint rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds nothing beyond the endpoint string: it doesn't say whether 'reset preview' is a dry-run computation, what data it computes over, or whether it requires the lease to be in a particular accounting state. For a preview/computation endpoint, that missing semantics is significant.

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 opening sentence is duplicated verbatim, which is pure waste, and the remaining content is metadata boilerplate (operation ID, describe_operation pointer) rather than front-loaded purpose. Short, but under-specified rather than concise.

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

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

No output schema, no annotations gap to lean on, 0% param coverage, and a nested free-form query object: this is a case where the description needed to carry real weight. It supplies none of the information an agent needs to decide to call it or interpret the preview result, deferring everything to describe_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 0%, so the description must compensate and it does not: the required `id` path param and an untyped free-form `query` object are never explained. No mention of format for the lease id, what query filters (if any) are honored, or defaults. The description only tells the agent to go look elsewhere.

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 is just the raw endpoint restated twice (identical sentence duplicated), plus an operation ID and a pointer to describe_operation. There is no verb/resource explanation of what an 'accounting-reset-preview' actually returns or means, and nothing distinguishes it from the many sibling get_accounting_leases_by_id_* endpoints. The path is the only semantic signal, making this close to tautology.

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

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

No statement of when to call this versus the dozens of sibling lease-accounting GET endpoints (e.g. get_accounting_leases_by_id_journal_ent_*, get_accounting_leases_by_id_amortizatio_*). The only guidance is an implicit redirect to describe_operation, which places the burden entirely on another tool rather than telling the agent when this preview is appropriate.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds nothing beyond pointing at describe_operation for request schemas — no note on auth, scoping, whether the schedule is computed or persisted, or what an empty result means.

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, and the first is duplicated word for word — pure waste. The one useful piece of information (describe_operation) is buried at the end of an operation ID string.

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

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

A read endpoint with no output schema, a nested unconstrained query object and 0% schema description coverage needs prose to be callable correctly. Nothing here explains the response shape, filtering via query, or units/periods of the schedule, so an agent must blindly call describe_operation first.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, and it largely doesn't. The path template at least reveals that 'id' is a lease identifier, which the schema itself never states, but the free-form 'query' object is entirely unexplained.

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 REST path does convey a verb (GET) and a resource (a lease's amortization schedule), and the path token distinguishes it from siblings such as payment_sch or liability_s_ under the same leases/:id family. But the intent is only inferable from a URL fragment, and the sentence is repeated verbatim with no plain-language statement of what an amortization schedule is.

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

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

The only routing hint is 'describe_operation provides native request schemas', which tells the agent to make a meta-call but says nothing about when to fetch amortization versus payment schedule or liability schedule, or what preconditions 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that: no pagination behavior, no filter semantics for the free-form `query` object, no statement of what is returned or whether the lease must exist. It does not contradict the annotations, but it contributes no extra behavioral context.

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

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

Two sentences, and the first is the identical path repeated twice — pure waste. The only non-redundant content is the trailing clause about describe_operation, which is buried at the end rather than 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?

No output schema exists, but the description never compensates: it gives no return-value shape, no pagination guidance, and no param semantics for a tool with 0% schema coverage and a required nested `params` object. For a read endpoint on a deeply nested lease resource, an agent cannot call this correctly from the description alone.

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

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

Schema description coverage is 0% across two parameters, so the description bears the full burden and discharges none of it. The `:id` in the path weakly implies `params.id` is the lease identifier, but nothing explains the free-form `query` object's accepted keys (pagination? filters?), which is exactly the gap the schema leaves open.

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 is a verbatim restatement of the URL path already embedded in the tool name and title, repeated twice. It conveys that this is a GET of lease classification tests only through the raw path string, with no plain-language statement of what a 'classification test' resource is or what the response represents. Effectively tautological.

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

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

The only actionable sentence points at describe_operation for native request schemas, which is a routing hint but not a when-to-use rule. There are at least two siblings keyed on leaseId/classification-tests (get_accounting_leases_by_leaseId_classi_...) and dozens of other lease-by-id sub-resource getters, and the description does nothing to say which to pick or when.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds nothing beyond that profile—no pagination, no shape of the direct-cost record, no permission scope. It does not contradict the annotations.

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?

Short, but the first sentence is duplicated verbatim, and no content is front-loaded beyond the path. Brevity here comes from under-specification rather than economy.

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

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

No output schema exists, and the description carries none of the burden of explaining return values, response shape, or query semantics for a nested-object request. For a two-parameter nested request with zero schema documentation, far more is needed.

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

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

Schema description coverage is 0% and there are two parameters (a required path id and an untyped query object). The description only mirrors ':id' from the URL and says nothing about the id format or what query filters are accepted, so it fails to compensate for the coverage gap.

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

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

The description is a verbatim restatement of the endpoint path in the tool name/title, repeated twice. An agent can infer 'fetch direct costs for a lease by id', but nothing explains what a direct cost is or how this differs from the dozens of sibling get_accounting_leases_by_id_* sub-resource tools.

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

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

There is no when-to-use guidance, no prerequisites, and no naming of alternatives. The only actionable sentence points at describe_operation for schemas, which is a workflow hint rather than usage guidance for this tool's 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds nothing beyond that — no note on what 'readiness' means, what states it returns, or whether it requires a closed period — so it contributes no behavioral context of its own.

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

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

The same sentence appears twice verbatim, which is pure waste, and the trailing Operation ID/describe_operation note is boilerplate rather than front-loaded intent. It is short, but the redundancy means the space is not earned.

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, zero schema description coverage, and a nested 'query' object, the description carries a lot of unanswered burden: it says nothing about the response shape, what 'readiness' evaluates, or how to use the query object. An agent would have to call describe_operation or guess.

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

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

Schema description coverage is 0% and neither parameter is documented in the schema. The description only conveys that :id is a path identifier (implicitly a lease id) via the URL template, and says nothing about the free-form 'query' object, which is completely unexplained.

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 endpoint path encodes a specific verb and resource hierarchy (leases → :id → journal-entry-readiness), so an agent can infer it returns journal-entry readiness info for one lease. But the description is literally the name/title restated with no plain-language elaboration, and it does nothing to distinguish this tool from the three sibling tools named get_accounting_leases_by_id_journal_ent_30923b87..., _c70603dd..., and _d40f358e..., which look identical by name.

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

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

There is no statement of when to use this versus the many related lease readiness/journal-entry tools (e.g. get_journal_entries_readiness, get_review_readiness, the other journal_ent siblings). The only guidance is a pointer to describe_operation for native request schemas, which is routing advice for schema lookup, not usage scoping.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered structurally. The description adds nothing beyond that — no statement of permissions, ordering, or what the 'source' payload represents — so it contributes essentially zero behavioral context.

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

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

The same sentence is duplicated verbatim before the operation ID, which is pure waste rather than front-loading. The content that remains (operation ID plus a pointer to describe_operation) is short but carries no substantive information an agent could act on.

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

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

With no output schema, zero parameter descriptions, and three nested path identifiers, the description would need to explain both the returned resource and the path semantics. It does provide a useful escape hatch by naming describe_operation for native schemas, but otherwise leaves an agent unable to call the tool correctly from this definition alone.

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

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

Schema description coverage is 0%, and the schema only constrains id/entryId/lineId as 1-2000 character strings with no meaning attached. The route template in the description weakly maps these to lease, journal entry, and line identifiers, which is the only semantic value added, but it never explains the untyped 'query' object or accepted formats.

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 is a verbatim repetition of the route template, which also appears in the title, so it restates structured data rather than explaining purpose. The path segments do hint that it retrieves the 'source' record for a specific journal entry line under a lease, but an agent gets no plain-language statement of what that resource actually is.

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

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

There is no guidance on when to use this tool versus the many sibling lease/journal-entry endpoints (e.g. get_accounting_leases_by_id_journal_ent_* variants or get_journal_entries_by_id_*). The only implicit routing hint is the note that describe_operation provides native request schemas, which tells the agent to look elsewhere for details but not when this call is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so safety behavior is covered. The description adds nothing beyond the annotations—no return behavior, pagination, or scoping details—so it barely helps the agent understand how the tool behaves.

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