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

With no annotations, the description carries the full burden; it does disclose the state transition (DRAFT to active) and the side effect of starting invoice generation, plus a user-confirmation requirement. It omits reversibility (that pause/resume can undo it), error behavior when the schedule is not in DRAFT, and any permission requirements.

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

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

Two short sentences, front-loaded with the action and effect, then the safety caveat. Every clause earns its place with no redundancy.

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

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

For a single-parameter state-change tool with no output schema, the description covers precondition, effect, and the confirmation requirement. It falls just short by not covering failure modes or routing to the pause/resume siblings.

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

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

Only one parameter (id) and schema description coverage is 100%, so the schema already documents it as 'Recurring schedule ID to activate'. The description adds no format or sourcing detail (e.g., where to obtain the ID via search_recurring_schedules), so the baseline 3 applies.

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

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

States a specific verb (Activate) and resource (DRAFT recurring invoice schedule) and explains the resulting effect ('begins generating invoices on its cadence'). However, it never distinguishes itself from the near-twin sibling resume_recurring_schedule, leaving the DRAFT-vs-paused distinction to inference.

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

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

The DRAFT precondition implies when this tool applies and 'Confirm with the user first' gives a workflow guardrail, but it never names pause_recurring_schedule or resume_recurring_schedule as alternatives or states when not to use it. Usage is implied rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden and does disclose the key consequence: it discards the session's clearing state. It also adds a user-confirmation safeguard, which is meaningful for a destructive operation. It stops short of stating reversibility or required permissions.

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

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

Two short clauses with zero filler; the destructive action is front-loaded and the safeguard follows immediately. Every element 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 single-parameter destructive tool with no annotations and no output schema, the description covers purpose, effect, and a confirmation requirement. It lacks permissions/reversibility notes and any pointer to the counterpart completion tool, so it is nearly complete but not fully rounded out.

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

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

Schema coverage is 100% and the sole id parameter is already documented as the Bank_ReconSession_Id to cancel. The description adds no format, range, or sourcing detail beyond the schema, so the baseline 3 applies.

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

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

Uses a specific verb (cancel) plus resource (in-progress reconciliation session) and the parenthetical clarifies the exact effect. It is readily distinguishable from the sibling start_reconciliation and complete_reconciliation tools without opening any schema.

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

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

"In-progress" implies the session state that qualifies for cancellation and "confirm with the user first" gives a pre-invocation check, but no alternative is named (e.g., complete_reconciliation when the session should be finalized) and no when-not guidance is offered. Usage is implied rather than stated.

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

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

With no annotations, the description carries the full burden and does disclose a key failure mode (unresolved difference blocks completion) and a human-in-the-loop precondition. It does not state whether completion is reversible, what state the session locks into, or any auth requirements.

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

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

Three short, front-loaded sentences with zero filler; the core action leads and the conditional/confirmation caveats follow in order of importance.

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 three-parameter mutation tool with no output schema and no annotations, the description covers the essential call path, the failure condition, and the confirmation requirement. It could say more about post-completion state or irreversibility, but the agent has enough to invoke it correctly.

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

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

Schema coverage is 100%, so id, notes, and forceComplete are already documented with descriptions. The description reinforces the forceComplete intent ('unless forceComplete is set') but adds no syntax or format meaning beyond the schema's own 'use with care' note; baseline 3 applies.

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

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

States a specific verb+resource ('Complete/finish a reconciliation session'), which unambiguously identifies the target entity. It is distinguishable in intent from siblings like start_reconciliation and cancel_reconciliation, though it never names them explicitly.

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

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

Gives real conditional guidance: it fails when a difference remains unless forceComplete is set, and instructs confirming with the user first. It stops short of naming cancel_reconciliation or other session-management alternatives as the when-not path.

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

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

With no annotations, the description carries the full behavioral burden and does well: it signals a write operation via the scope requirement, names a dependency (Sales module), and adds a user-confirmation safety step. It doesn't say whether the source proposal is left untouched or how failures surface, so it isn't exhaustive.

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

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

Three short sentences with zero filler, ordered as purpose, then prerequisites, then the safety directive. Each sentence earns its place and the key action is front-loaded.

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

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

For a one-parameter mutation with no output schema, the description covers purpose, module/scope prerequisites, and the confirmation step. It omits what the resulting draft inherits from the source (fields, status, line items), which would round it out, but return values need not be explained given no output schema.

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

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

Schema description coverage is 100% for the single proposal_id parameter, so the schema already explains it fully. The description adds no format, sourcing, or constraint detail beyond the schema, making the baseline 3 appropriate.

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

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

States a specific verb (duplicate) and resource (proposal) plus the outcome (a new draft), which cleanly separates it from read siblings like get_proposal/search_proposals and from actions like generate_invoice_from_proposal or create_job_from_proposal. An agent can select it without opening any schema.

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

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

Gives real operational preconditions ('Requires the Sales module and the write scope') and a workflow instruction ('Confirm with the user before calling'), which is exactly the kind of context an agent needs before a mutation. It stops short of stating when to prefer this over alternatives, so no exclusion criteria are given.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nearly nothing: no auth/permission requirements, no uniqueness or duplicate-handling behavior, no indication of what happens to opening balances or parent accounts, and no note that this is a non-read-only mutation. 'Create' implies a write, but the safety and failure profile is entirely absent.

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

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

Two tight sentences with zero waste; the purpose is front-loaded and the requirement list follows immediately. Nothing needs trimming.

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

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

For a mutation tool with no annotations and no output schema, the description covers the required inputs but omits the return shape, permission needs, and duplicate/error behavior. It is minimally viable rather than complete.

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

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

The single top-level parameter is a nested object with no schema-level description (coverage reported as 0%), so the description's enumeration of required fields — account number, name, category, and type code — is genuinely useful routing information. It also names the category enum values, though those are redundantly present in the schema.

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

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

States a specific verb and resource ('Create a new account in the KikoBooks chart of accounts'), which clearly separates it from update_account, get_account, and search_accounts. It does not explicitly name a sibling, but the create-verb plus chart-of-accounts scope is unambiguous.

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

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

No guidance on when to use this versus search_accounts/get_account/update_account, or what to do if an account with the same number already exists. The create intent is only implied by the verb; there are no conditions, prerequisites, or exclusions stated.

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

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

No annotations are supplied, so the description carries the entire behavioral burden, yet it only says a bill is created. It does not disclose side effects (AP aging, journal entries), whether billNumber is auto-generated when omitted, permission requirements, or whether the operation is reversible.

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

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

Two tight sentences with the core action front-loaded and zero filler. It is efficient, though the brevity is partly under-specification rather than disciplined concision.

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

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

For a mutation tool with a nested object payload, no annotations, and no output schema, the description is too thin. An agent gets no information about the effects of creating a bill, required permissions, or how the nested bill object maps to outcomes.

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% at the top level, so the description must compensate, and it does so only partially by naming vendor ID, dates, and line items. The nested schema itself does describe individual fields (memo, dueDate, lineItems, accountId, taxCode), so the description adds a useful required-field summary but no format or meaning beyond it.

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

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

States a specific verb and resource ("Create a new bill (accounts payable)") scoped to KikoBooks, which lets an agent distinguish it from siblings like update_bill, get_bill, and create_bill_payment. It stops short of explicitly contrasting those siblings, so it is clear but not fully differentiating.

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

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

The description gives no when-to-use guidance, no prerequisites (permissions, vendor must exist), and no routing advice versus the many sibling creation tools (create_bill_payment, create_purchase, create_invoice). Naming required fields is a light prerequisite hint at best.

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

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

With no annotations, the description carries the full behavioral burden but says almost nothing beyond 'this creates a payment'. There is no mention of GL posting behavior, the AutoPost default of true that the schema hints at, required permissions, reversibility, or how a created payment is later voided. For a financial write operation this is a substantial disclosure gap.

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

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

Two short sentences, zero filler, with the required-field contract front-loaded before the optional application behavior. Every clause earns its place.

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

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

This is a nested, multi-field AP mutation with no annotations and no output schema, yet the description covers only the required quartet plus applications. Defaults, posting semantics, and the remaining optional fields are left entirely to the schema, which is thin on meaning here.

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

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

Top-level schema description coverage is 0% (the single 'payment' wrapper object is undocumented), so the description must compensate. It does map the four required fields to plain-English concepts and flags the Applications array as optional, but it says nothing about PaymentMethod, CurrencyCode defaults, CheckNumber, or the Memo/Notes fields.

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

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

States a specific verb and resource ('Create a bill payment (AP) in KikoBooks'), and the '(AP)' qualifier nudges it apart from the generic create_payment sibling. It stops short of explicitly naming create_payment or create_bill as the alternatives, so an agent must infer the boundary itself.

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

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

The description gives prerequisites ('Requires vendor ID, payment date, source account, and amount') and an optional flow ('apply to specific bills'), which implies when the tool is applicable. It never states when NOT to use it, nor routes to create_payment, create_bill, or void_bill_payment, so usage guidance is only implied.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only restates the schema's required fields and the optional invoice link; it does not say whether the memo is posted to AR/GL, whether it requires specific permissions, whether the operation is reversible, or what defaults apply to currency and accounts.

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

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

Three short, front-loaded sentences with no filler; purpose comes first, then requirements, then the optional linkage. The requirements sentence partly duplicates the schema's required array, which is the only mild redundancy.

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

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

For a mutation tool with a deeply nested payload (~15 line/header fields), no annotations, and no output schema, the description is too thin. It omits whether a result ID is returned, posting/approval behavior, error conditions on invalid customer or reason codes, and guidance on the optional header fields.

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?

Top-level schema coverage is 0% and the single 'creditMemo' object is undocumented in the schema, so the description must compensate. It names the required members (customer, date, reason code) and adds the real constraint that at least one line item is needed (not encoded as minItems in the schema), but it says nothing about the many optional fields (CurrencyCode default, GL overrides, customer/internal messages) or the nested line-item shape.

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

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

States a specific verb and resource ('Create a credit memo (AR) in KikoBooks'), which cleanly separates it from the read-side siblings search_credit_memos and get_credit_memo. The AR qualifier pins the domain unambiguously.

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 closing line 'Can be linked to a specific invoice' implies one usage context, but there is no explicit when-to-use vs alternatives (e.g. void_bill, create_payment/refund) and no prerequisites or exclusions. Usage is only inferable from the note about invoice linking.

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

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

No annotations are supplied, so the description must carry the full behavioral burden. It says that a new customer is created and that displayName is the minimum requirement, but it omits duplicate handling, authentication needs, validation behavior, side effects, and response characteristics.

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

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

The description is two compact sentences, front-loads the action and required field, and contains no filler. Every sentence contributes directly to understanding the operation.

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

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

For a create tool with a nested object, no annotations, and no output schema, the description is too thin. It covers the minimum viable call but leaves important behavioral, field-level, and integration context unaddressed.

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

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

The schema exposes many nested customer fields, but the description adds useful high-level grouping: required display name, optional contact details, billing address, and payment terms. It does not map every optional field or specify formats, so it partially compensates for limited schema-level guidance.

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

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

The description states a specific verb and resource: 'Create a new customer in KikoBooks.' It is clear and actionable, though it does not explicitly differentiate from siblings such as update_customer, delete_customer, or promote_deal_to_customer.

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

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

The description implies use when creating a new customer and gives the minimum required field, but it does not say when to choose this over update_customer, promote_deal_to_customer, or other creation alternatives. No exclusions or broader workflow context are provided.

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

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

No annotations are provided, so the description carries the full burden; it does disclose the module/scope prerequisite and a confirmation requirement, both of which are real behavioral context beyond the schema. It is silent on side effects (e.g., whether the originating lead is marked converted) and on what is returned, which leaves some gaps for a write tool.

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

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

Four front-loaded sentences with no padding: purpose, then required/optional fields, then prerequisites, then the confirmation rule. It is list-heavy in the middle but every element 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?

With a nested-object schema, no output schema and no annotations, the description covers purpose, prerequisites, and field expectations adequately for a create tool. The remaining gap is the absence of any statement about the result or side effects of creation, which an agent would otherwise have to infer.

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

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

The schema's nested properties each carry their own descriptions, and the description reinforces this by naming the three required fields and most optional ones (value, currency, status, close date, probability, tags). It omits a few optional fields (customerId, proposalId, notes), but those remain documented in the schema, so no meaning is lost.

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 opens with a specific verb+resource ("Create a new CRM deal") and immediately disambiguates the domain with "(sales opportunity) from a lead," which distinguishes it from create_lead and from update_deal/move_deal_stage. An agent can classify it correctly without opening the schema.

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

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

It states concrete preconditions (Sales module enabled, write scope) and an explicit behavioral instruction ("Confirm with the user before calling"), which is usable guidance. It doesn't route the agent to any alternative (e.g., update_deal for modifying an existing deal), so it stops short of the when-not/alternatives bar.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the record is created as a DRAFT, that posting has a specific ledger effect (DR Bank, CR Undeposited Funds), and that posting is a separate step. It stops short of stating permission/auth requirements or how to undo a created draft (delete_deposit exists as a sibling).

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

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

Three short sentences, front-loaded with the action and condensed further into the accounting effect, then the lifecycle constraint, then the interaction rule. No filler and no restatement of the name.

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

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

For a 10-parameter, 4-required mutation tool with no annotations and no output schema, the description covers the essential lifecycle (draft vs posted), the ledger impact, and the human-confirmation requirement. The one gap is the return value: an agent needs the new deposit's id to call post_deposit, and that is not stated.

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

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

Schema description coverage is 100%, with all 10 params documented in the schema itself, so the baseline is 3. The description only adds the notion that the lines are undeposited payments/receipts, which the schema's 'Deposit lines' text largely already conveys; it adds no format, currency, or cash-back guidance beyond the schema.

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

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

States a specific verb+resource (Create a bank deposit) and pins down what it is made from: undeposited payments/receipts. It also names the accounting effect and the sibling that continues the lifecycle (post_deposit), so an agent can separate it from create_payment, update_deposit, and post_deposit without opening any schema.

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

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

Explicitly routes the agent forward ('use post_deposit to post it') and imposes a workflow precondition ('Preview and confirm with the user before calling'). It does not, however, say when a deposit is the right construct versus creating individual payments/receipts, so one piece of alternative-selection guidance is missing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses a confirmation-before-commit requirement, but says nothing about permissions, reversibility, side effects on the ledger, or what happens to the optional depreciation settings. Real but partial disclosure.

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

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

Two tight sentences that front-load the core action before the optional-depreciation qualifier. The parenthetical earns its place by enumerating the depreciation sub-fields; nothing is wasted.

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

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

For a 21-parameter mutation with no annotations and no output schema, the description is thin. The confirmation instruction helps, but the create operation's effects and safety profile are largely undocumented, leaving an agent to infer them from the schema alone.

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

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

Schema description coverage is 100%, so all 21 parameters are already documented in the schema. The description groups the depreciation-related params (method, useful life, salvage, GL accounts) but adds no syntax, format, or constraint detail beyond what the schema provides. Baseline 3 applies.

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

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

States a specific verb (Register) and resource (new fixed asset), plus names the optional depreciation settings it accepts. The word 'new' implicitly separates it from update_fixed_asset and dispose_fixed_asset, though those siblings are never named explicitly.

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

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

The 'optionally with depreciation settings' phrasing implies the depreciation params are elective, and 'Preview and confirm with the user first' gives a workflow step. However, there is no explicit when-to-use vs. update_fixed_asset/dispose_fixed_asset guidance and no stated prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a create/mutation but says nothing about permissions, whether the draft is posted or final, idempotency, or what happens to unsupplied defaults — all relevant for a finance write operation.

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

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

Two sentences, both front-loaded and free of filler: the action first, then the required inputs. Efficient and easy to scan.

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

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

For a mutation tool with nested objects, no annotations, and no output schema, the description is thin — it covers required inputs but leaves behavior, side effects, and handling of the nested lineItems/optional fields unexplained.

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

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

Top-level schema description coverage is 0%, so the description must compensate, and it does name the required inputs (customer ID, dates, and line item description/quantity/unit price). However, it omits the many optional fields (memo, termsCode, currencyCode, billing address) that an agent may need to set.

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

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

States a specific verb and resource ('Create a new invoice in KikoBooks'), clearly distinguishing it from search/get/update invoice siblings and from create_bill or create_credit_memo. It does not, however, differentiate itself from generate_invoice_from_proposal or generate_invoice_from_job, which are the closest conceptual alternatives.

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

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

The description lists required inputs but gives no guidance on when to use this tool versus generate_invoice_from_proposal, generate_invoice_from_job, or generate_recurring_invoice. No prerequisites, ordering, 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?

No annotations are provided, so the description carries the full behavioral burden. It only restates the required/optional field shape and says nothing about permissions, duplicate handling, side effects, or what is returned for this write operation.

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

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

Two tight sentences with the required field stated up front and no wasted wording. Well front-loaded and appropriately sized for a simple create tool.

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

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

For a mutation tool with no annotations and no output schema, the description covers shape but not behavior. The nested schema documents individual sub-fields, which partially compensates, but an agent still lacks guidance on type enum meaning, account ID semantics, and post-create behavior.

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

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

The description groups the optional fields into meaningful categories ('pricing, type, and account mappings'), which maps onto costPrice/unitPrice, the type enum, and incomeAccountId/expenseAccountId. This adds some interpretive value, but the reported schema coverage is 0% at the top level and the description omits the enum values and field-level distinctions.

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

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

States a specific verb and resource ('Create a new product/service item in KikoBooks'), which cleanly separates it from search_items/get_item/update_item siblings. It does not explicitly name an alternative, but the creation intent is unambiguous.

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

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

The description implies usage by naming the required and optional fields, but gives no when-to-use vs. alternatives guidance (e.g., when to create vs. update_item) or any preconditions. Adequate minimum but with a clear gap.

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

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

With no annotations, the description carries the full burden and does disclose real behavioral context: it requires the Sales and Workflow modules plus the write scope, and it mandates user confirmation before execution and verification afterward. It stops short of describing reversibility or what happens to the source proposal (the archive side-effect lives only in the schema).

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

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

Three tight sentences, front-loaded with the action, the bridge framing, the hard requirements, and the operational steps. No filler and nothing buried.

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

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

For a no-output-schema mutation tool, it covers prerequisites, the required modules/scope, the confirmation step, and the verification path. Only reversibility and the archive behavior are left unstated, which are minor gaps given the schema covers the parameters.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters including the two required ones. The description only reinforces that proposal_id and job_name are required and should be user-confirmed, adding little beyond the schema's own 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?

States a specific verb (Create) and resource (a job with tasks) and the source (an accepted proposal's line items), then labels itself the 'Proposal → Workflow bridge,' which cleanly separates it from sibling generators like generate_invoice_from_proposal and copy_proposal.

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

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

Gives clear context: the source proposal must already be accepted, and it prescribes a confirm-before-calling and verify-with-search_jobs workflow. It does not explicitly contrast the tool against the nearby generate_invoice_from_proposal / copy_proposal alternatives, so it falls just short of explicit alternative routing.

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

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

With no annotations, the description carries the full burden, and it does add real behavioral context: the debit/credit balance invariant and irreversible immutability after posting. However, the key question the immutability claim raises — does create_journal_entry itself post the entry, or is posting a separate step via post_journal_entry? — is left unanswered, and nothing is said about permission requirements or what is returned.

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

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

Three tight sentences, front-loaded with the action, then requirements, then the behavioral warning. Every sentence carries weight; only the brand mention 'in KikoBooks' is mildly expendable.

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

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

For a mutation tool with a nested object, no annotations, and no output schema, the description covers the balance requirement and post-creation immutability but omits whether the result is a draft or posted entry, what identifier is returned, and how imbalance errors surface. It is adequate but leaves the agent guessing on the create/post lifecycle.

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

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

Only one top-level parameter, and the description reinforces the required fields (entry date, lines) and the balancing constraint. The nested schema already documents accountId, debitAmount/creditAmount exclusivity, and the debit-equals-credit rule, so the description adds modest but non-zero meaning. With a single param and adequate nested schema documentation, this is near the baseline-plus range.

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

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

States a specific verb and resource ('Create a manual journal entry in KikoBooks'), and the immutability note implicitly separates this tool from the sibling post_journal_entry and reverse_journal_entry. It does not name those siblings directly, so an agent still has to infer the create-vs-post boundary rather than being told 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?

Usage is only implied: 'manual' entry plus the note that corrections require reversal entries suggests when to reach for this tool versus post_journal_entry or reverse_journal_entry. It never states the condition that selects this tool over its siblings, nor whether the entry is created as a draft to be posted later.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses auth requirements (Sales module, write scope) and a confirm-before-write workflow, which goes beyond the schema. It says nothing about duplicate detection, validation failures, or what is returned after creation.

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

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

Three sentences, zero filler, front-loaded with the action and required fields before prerequisites and the confirmation instruction. Every sentence earns its place.

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

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

For a mutation tool with no annotations and no output schema, the description covers fields, permissions, and a safety workflow but omits what the call returns (e.g., the created lead ID) and any duplicate-handling behavior. Adequate but with clear gaps for an agent wiring the result into a follow-up step.

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?

Top-level coverage is 0% (the single 'lead' object is undescribed), but the description compensates by naming the required fields (first/last name) and grouping the optional ones (company, contact details, status, score, source, tags) in a way that maps onto companyName, email/phone, leadStatus, leadScore, leadSourceId, and tagIds. The nested schema also documents each field individually, so the agent has both layers.

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

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

States a specific verb and resource ('Create a new CRM lead') and immediately enumerates the required and optional field groups. The resource name distinguishes it cleanly from create_deal and create_customer in the sibling list without the agent needing to open any schema.

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

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

Gives concrete preconditions ('Requires the Sales module and the write scope') and a procedural directive ('Preview the details and confirm with the user before calling'). It does not, however, state when to prefer this over create_deal or how to handle a lead that may already exist (search_leads), so routing guidance is incomplete.

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

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

No annotations, so the description carries the full behavioral burden. It says 'Create' (a mutation) and mentions optional allocation, but omits auth/permission needs, whether the payment is created as draft or posted, how AutoPost or allocations behave, and whether it can be reversed/voided. Significant gaps for a financial write operation.

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

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

Two tight sentences with the required-input contract front-loaded ahead of the optional allocation detail. No filler, though it is quite terse for a multi-field object payload.

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

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

For a nested, annotation-free mutation tool with no output schema, the description covers the core intent and required fields but leaves behavioral questions open (posting state, allocation rules, error/reversal behavior). Adequate but with clear gaps.

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

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

The description restates the schema's own required fields (customer ID, date, method, amount) and the allocation option, adding little beyond the structured schema. The nested properties in the schema are individually documented, so the baseline of 3 applies; the description does not explain constraints like whether allocations must sum to the amount.

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

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

Clear specific verb+resource: 'Create a customer payment (AR)' in a named system. The '(AR)' qualifier plus 'customer payment' implicitly distinguishes it from siblings like create_bill_payment (AP) and create_deposit, though no sibling is named explicitly.

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

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

States the required inputs and the optional allocation use case, which implies when to use it, but gives no explicit when-not or alternative routing (e.g., vs create_deposit, create_sales_receipt, or create_bill_payment). Usage context is inferable but not spelled out.

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

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

With no annotations at all, the description carries the full behavioral burden for a mutation tool and largely fails to: it does not say whether the purchase is created as draft or posted, what the accounting side effects are, what happens if accountId or paymentAccountId are omitted, or whether vendorId is required in practice. The only added context is the purchase/expense equivalence, which is thin for a write operation.

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

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

Two tight sentences with the core verb/resource front-loaded and no filler. It is efficiently written; the issue is underspecification rather than verbosity.

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

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

For a nested-object mutation tool with no annotations and no output schema, the description should explain permissions, draft/posted behavior, and the account-field semantics. None of that is present, leaving an agent with only the schema to infer how to build a valid, correctly-categorized purchase.

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 reported at 0%, so the description is expected to compensate, but it only restates that line items need amounts and 'expense accounts'. It never clarifies the critical distinction between lineItems.accountId (expense GL account) and purchase.paymentAccountId (bank/cash account), nor the role of vendorId, taxCode, or referenceNumber.

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

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

States a specific verb and resource ('Create a purchase') and disambiguates the domain term with the parenthetical '(expense)'. It does not differentiate itself from adjacent write siblings like create_bill or create_invoice, but the purpose itself is unambiguous.

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

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

The second sentence lists required inputs ('expense date and line items'), which is a prerequisite rather than usage guidance, and that fact is already in the schema. There is no statement of when to create a purchase versus a bill or credit memo, nor any precondition such as a required vendor or connection 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?

No annotations exist, so the description carries the full disclosure burden. 'Requires date and at least one line item' merely restates schema requiredness; it says nothing about GL/deposit-account side effects, permission needs, reversibility (no void/delete sibling for sales receipts), idempotency, or the response. For a posting mutation tool this is a significant gap.

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

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

Three short sentences, front-loaded with the action, then the conceptual distinction, then the requirement. No filler, though the requirements sentence duplicates information the schema already mandates.

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 mutation tool with no annotations and no output schema, the description omits side effects, required permissions, failure modes, and what the call returns. What an agent needs to call this safely and correctly is largely absent.

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

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

Top-level schema description coverage is 0% and the description compensates only by restating the required fields (ReceiptDate, Lines) that the schema already enforces. It adds no format hints, defaults, or meaning for the many optional nested fields such as DepositToAccount_Id, PaymentMethodCode, or Customer_Id's walk-in behavior.

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

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

States a specific verb and resource (create a sales receipt) and goes further by defining what a sales receipt represents in accounting terms — an instant payment+sale with no separate invoice. That definition implicitly separates it from create_invoice without naming the sibling explicitly, so it stops just short of a 5.

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

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

The parenthetical 'no separate invoice needed' is effectively a use-this-instead-of-an-invoice rule and gives an agent a clear condition for choosing this tool over create_invoice. It stops short of 5 because no alternative is named outright and no when-not-to-use case (e.g. credit sales) is stated.

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

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

With no annotations, the description carries the full behavioral burden, and it only implies a mutation via "Create." It says nothing about permissions/auth needs, duplicate-name behavior, idempotency, or what the call returns on success or failure.

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

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

Two tight sentences with the required field stated up front and optional fields summarized after; no filler. The grouping of optional fields is slightly lossy but nothing is wasted.

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

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

For a nested 15-field create tool with no annotations and no output schema, the description covers the essentials (required name, some optional groups) but leaves several fields unexplained and gives no post-call expectations (created vendor ID, validation failures). Adequate but with clear gaps.

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

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

Schema description coverage is reported at 0% and the single top-level parameter is an undescribed nested object, so the description must compensate. It usefully names the required displayName and groups the optional fields (contact, address, 1099 eligibility), but omits currencyCode, paymentTermsCode, and the givenName/familyName/companyName fields entirely.

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?

"Create a new vendor in KikoBooks" gives a specific verb and resource, and the create/update/delete vendor sibling set is trivially distinguished by the verb. It does not, however, differentiate itself from any other create_* tool beyond the resource name.

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

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

The description states what is required versus optional but never says when to reach for create_vendor versus search_vendors, get_vendor, or update_vendor. No prerequisites or exclusions (e.g., duplicate handling, when to update instead) are given.

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

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

No annotations are provided, so the description carries the full burden. It does add genuine behavioral value by disclosing that this is a soft delete that sets the customer inactive rather than removing the record. However, it omits permission requirements, whether the customer can be reactivated, and whether it still appears in search_customers results.

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

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

Two short sentences, zero waste, with the core action and its soft-delete semantics front-loaded. Nothing is padded or redundant.

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

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

For a single-parameter tool with no output schema, the description covers the essential semantics (soft delete/deactivate). The main gap is the absence of any recoverability or permission context, which would be useful given no annotations exist.

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

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

Schema description coverage is 100% and the single parameter is documented in the schema itself, including the soft-delete note. The description adds nothing beyond what the schema already states, so the baseline 3 applies.

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

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

The description states a specific verb (Delete) and resource (customer in KikoBooks) and even clarifies the semantic meaning of the verb with '(deactivate)'. It does not need to differentiate from siblings since the resource is unique among the delete_* tools, though it could note how it differs from update_customer.

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

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

There is no guidance on when to use this tool versus alternatives such as update_customer to set a customer inactive, nor any prerequisites or warnings. The agent must infer the usage context entirely.

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

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

With no annotations, the description carries the full burden and does well: it discloses the soft-delete (recoverable) semantics, the DRAFT-only precondition, the failure mode for posted deposits, and a user-confirmation requirement. It omits permission requirements and what happens to records linked to the deposit.

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

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

Three short sentences, each carrying a distinct piece of information: action, alternative, and the confirmation requirement. Front-loaded with the core action and no filler.

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

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

For a single-parameter destructive tool with no annotations or output schema, the description covers the essential risks: scope limit, alternative path, and user confirmation. Only permission/error behavior is left unstated, which is a minor gap.

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

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

One parameter at 100% schema coverage; the schema already says 'Deposit ID to delete (DRAFT only)'. The description's DRAFT restriction is identical to what the schema states, so it adds no format, type, or lookup detail beyond structured data.

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 ('Soft-delete a DRAFT deposit') plus the state restriction that defines it. It is immediately distinguishable from the sibling void_deposit, which the description explicitly routes posted deposits to.

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

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

Gives a clear when-to-use (DRAFT deposits) and when-not (posted deposits must be voided instead), which maps onto the sibling void_deposit. It stops just short of naming that tool explicitly, so the routing requires a small inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says only that a record is deleted, with no disclosure of irreversibility, required permissions, cascading effects on linked records, or error behavior for a nonexistent ID. For a destructive mutation with zero annotation coverage, this is a significant gap.

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

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

A single short sentence with no filler, and the verb and resource are front-loaded. It is efficient, though arguably under-specified rather than maximally concise.

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

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

For a destructive mutation with no annotations, no output schema, and no confirmation/permission detail, the description is too thin to let an agent call it safely. It leaves irreversibility and side effects entirely undocumented.

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

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

Schema description coverage is 100% and the single purchase_id parameter is documented as 'The Purchase/Expense ID to delete.' The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource ('Delete a purchase') and clarifies the domain term as an expense, which helps disambiguate from invoices/bills. It does not explicitly differentiate from sibling mutators like void_bill, but the operation and target are unambiguous.

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

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

No guidance on when to delete versus void or reverse, no preconditions, and no mention of related tools such as get_purchase for verifying the record first. The agent must infer usage entirely from the name.

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

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

With no annotations, the description carries the full burden and does meaningful work: 'soft-delete' signals the record is not permanently destroyed, and 'DRAFT' states an eligibility restriction that would otherwise be invisible. It still omits what happens to the schedule's status/records and what errors occur for non-draft schedules, so it is good but not complete.

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

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

Two short sentences with zero filler; the core action and its scope are front-loaded and the confirmation requirement follows immediately.

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

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

For a single-parameter deletion tool with no annotations and no output schema, the description covers the essential facts: what is deleted, that it is soft, and that it is restricted to DRAFT with user confirmation. It could still note the sibling alternative (pause) and post-delete state, which is why it is not a 5.

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

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

Schema description coverage is 100% for the single 'id' parameter and even mirrors the description's DRAFT-only constraint. The description adds no syntax, ID-format, or lookup guidance beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Soft-delete a ... recurring invoice schedule') plus a qualifying scope ('DRAFT'). The verb 'soft-delete' is precise and distinct from a hard delete, but the description never differentiates this from close siblings such as pause_recurring_schedule, resume_recurring_schedule, or activate_recurring_schedule, which an agent must choose between.

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

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

It gives one explicit operational rule, 'Confirm with the user first,' and an eligibility condition (DRAFT only). However, it offers no comparison against the alternative actions in the sibling set (pause vs. delete vs. deactivate), so the agent gets an implied context rather than real when/when-not guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the delete is soft (recoverable rather than destructive) and that is restricted to DRAFT statements, which is meaningful behavioral context. It still omits permissions required, post-delete state, and the 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?

Two short sentences with zero waste: the operation and its precondition come first, then the confirmation requirement. Nothing extraneous.

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

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

For a single-parameter, no-output-schema tool, the definition covers the operation, its scope restriction, and the user-confirmation step. The remaining gaps (post-delete recoverability path, error conditions for non-DRAFT ids) are minor.

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

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

Only one parameter, and schema description coverage is 100% – the schema already documents the id and its DRAFT-only constraint. The description restates that constraint rather than adding format or validation detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb ('soft-delete') and resource ('DRAFT customer statement'), with the scope constraint (DRAFT only) front-loaded. It distinguishes itself from hard-delete siblings by naming the soft-delete behavior, though it does not explicitly compare against void-style siblings such as void_bill.

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?

'Confirm with the user first' gives one actionable precondition, and the DRAFT-only framing implies when the tool is valid. However, no alternatives are named (e.g., what to do for a posted/reconciled statement), so the agent must infer the escape path.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that this is a soft delete setting the vendor inactive, which materially changes an agent's risk assessment. However, it says nothing about permissions, whether the change is reversible, or the effect on the vendor's existing bills/payments.

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

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

Two short sentences with zero waste; the soft-delete behavior is front-loaded alongside the action. Nothing is redundant or padded.

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

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

For a single-parameter, no-annotation, no-output-schema tool, the description covers the essential surprise (delete is actually deactivate). It is nearly complete, missing only the reversibility/auth details an agent might want before mutating data.

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

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

Schema description coverage is 100% and the single parameter's schema description already contains the same soft-delete note. The description adds no syntax, format, or lookup guidance beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Delete (deactivate) a vendor in KikoBooks') and clarifies the mode of deletion. An agent can tell what the tool targets, though it does not explicitly distinguish itself from siblings like update_vendor or void_bill.

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, prerequisites, or alternatives are given. It does not say how this differs from update_vendor (which could also set inactive) or when to prefer deactivation over other removal paths.

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

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

With no annotations, the description carries the full burden and does disclose the side effects: it creates a disposal record, updates asset status, and recognizes gain/loss. However, it omits irreversibility, required permissions, and whether the operation can be undone, which matters for a destructive financial write.

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

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

A single tight sentence with the action front-loaded and the confirmation requirement last; every clause earns its place.

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

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

Purpose, side effects, and the confirmation gate are covered, but for a 9-parameter financial mutation with no annotations and no output schema, the description says nothing about gain/loss calculation inputs, error/permission conditions, or the result shape. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so all 9 parameters are already documented in the schema. The description only echoes the disposal types already captured by disposalType; it adds no syntax, format, or defaults beyond the schema. Baseline 3 applies.

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

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

States a specific verb (dispose) and resource (fixed asset) with the disposal modes enumerated. It is clearly distinguishable from the other fixed-asset siblings (search_fixed_assets, get_fixed_asset, create_fixed_asset, update_fixed_asset, run_depreciation).

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

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

Gives a clear usage directive ('Confirm with the user first') that tells the agent this is a consequential action needing user consent. It also scopes the disposal modes (sale/scrap/donation), but names no alternative tool or explicit when-not 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?

With no annotations, the description carries the full behavioral burden and does well: it discloses that the result is a DRAFT, that nothing is posted to GL, that Workflow module and write scope are required, where the line data comes from, and that the result should be checked with get_invoice. It lacks failure/error or idempotency behavior, but the state-change and authorization profile is unusually well covered.

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

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

A single tight paragraph that front-loads the core action and scope, then layers prerequisites and a follow-up step in short clauses. Every sentence carries distinct information (draft status, no GL post, module/scope, confirmation, verification); nothing is padding.

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

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

For an 8-parameter mutation tool with no output schema and no annotations, this description covers the essential gaps: what is created (draft), what is not done (no GL post), prerequisites (Workflow module, write scope), and how to verify (get_invoice). It does not describe error cases or what the returned draft contains, but the get_invoice pointer largely compensates for the missing output schema.

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

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

Schema description coverage is 100%, so all 8 parameters are already documented (job_id, invoice_date required; due_date, customer_id, GL account overrides, include_expenses/include_timesheets, etc.). The description's mention of 'approved timesheets and billable expenses' only echoes what include_timesheets/include_expenses already say, so it adds no new parameter meaning beyond the schema baseline.

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

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

States a specific verb and resource ('Generate a DRAFT AR invoice from a job's approved timesheets and billable expenses') and explicitly frames itself as 'the Job → invoice bridge.' This cleanly distinguishes it from create_invoice (manual creation) and generate_invoice_from_proposal (proposal-based), so an agent can route correctly without opening sibling schemas.

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

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

Gives clear operational guidance: require the Workflow module and write scope, confirm job and date with the user before calling, then verify with get_invoice. It implies the from-job context but never explicitly contrasts with create_invoice or generate_invoice_from_proposal, so the when-not/alternative guidance is incomplete.

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

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

With no annotations, the description carries the full burden and does well: it discloses the output state (DRAFT, not posted to GL), the derivation logic (maps the selected pricing option's line items), and required module/scope. It does not address idempotency, duplicate-invoice handling, or what happens if the proposal is already invoiced. Squarely above average for an unannotated mutation tool.

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

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

Three front-loaded clauses: identity/scope, behavior/requirements, then verification. Each sentence earns its place. Slightly dense with em-dash and parenthetical asides, but no filler.

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

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

For a 6-param creation tool with no output schema, the description covers state (draft), side effects (no GL posting), prerequisites (Sales module, write scope), and a verification path in lieu of describing the return value. It lacks detail on error/failure cases (e.g., unapproved proposal) and whether the returned invoice ID is surfaced.

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

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

Schema description coverage is 100%, so the schema already documents due_date, terms_code, proposal_id, invoice_date, and both GL account overrides. The description adds only the high-level notion that line items come from 'the selected pricing option', with no guidance on the GL override params. Baseline 3 is correct when the schema does the heavy lifting.

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

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

The description gives a specific verb+resource ('Generate a DRAFT AR invoice from a signed/contracted proposal') and explicitly frames it as 'the Proposal → invoice bridge', which separates it from create_invoice, generate_invoice_from_job, and generate_recurring_invoice without the agent opening any schema.

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

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

It states the gating conditions ('Requires the Sales module and the write scope'), a pre-call workflow ('Confirm the proposal and terms with the user'), and a post-call action ('verify the created invoice with search_invoices or get_invoice'). It never explicitly says when to prefer create_invoice or generate_invoice_from_job instead, so it stops short of full alternative routing.

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

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

With no annotations, the description carries the full burden and does well: it discloses the resulting state ('Creates a DRAFT invoice'), a side effect on other data ('advance its next-run date'), and a required human-confirmation step. It does not mention idempotency (what happens on a repeat call) or behavior for paused/inactive schedules, which keeps it short of a 5.

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

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

Three short sentences, zero filler, and the core action and its side effect are front-loaded before the safety instruction. Every sentence earns its place.

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

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

For a one-parameter generation tool with no output schema, the description covers the action, the resulting draft state, the schedule mutation, and the confirmation requirement. The only material gap is what the tool returns (presumably the new draft invoice) and behavior against inactive schedules.

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

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

Only one parameter and schema description coverage is 100%, so the schema already explains that 'id' is the recurring schedule ID. The description confirms the schedule context but adds no format, range, or lookup guidance beyond the schema — the baseline 3 for a fully documented schema.

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

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

States a specific verb and resource ('Generate an invoice') plus the source of truth ('from a recurring schedule'), which distinguishes it from generate_invoice_from_proposal and generate_invoice_from_job. It also names the second effect ('advance its next-run date'), so the agent knows this is not a pure read or a plain create.

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

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

The instruction 'Confirm with the user first' is a genuine prerequisite and useful guidance, but the description never states when to use this over alternatives such as pause_recurring_schedule/resume_recurring_schedule or waiting for the scheduled run, nor any when-not condition. Usage is therefore implied rather than specified.

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

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

No annotations are provided, so the description carries the full behavioral burden. It partially discharges it by naming the payload ('balances, hierarchy, and metadata') and by using 'Get', which implies a side-effect-free read, but it never explicitly states the operation is non-mutating, nor what happens on a missing/invalid ID.

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

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

Two tight sentences with zero filler. The identity/scope information is front-loaded and the return-value note follows, which is the right ordering.

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 supplies the essentials: what is fetched, by what key, and roughly what comes back. It is only thin on failure/permission behavior, which is minor for a simple lookup.

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

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

Schema description coverage is 100% and the sole parameter is documented in the schema as 'The GL Account ID to retrieve'. The description's 'by ID' adds no syntax, format, or sourcing detail beyond that, so the baseline 3 applies.

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

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

States a specific verb ('Get'), a specific resource ('a single chart of accounts entry'), and the retrieval key ('by ID'). The word 'single' plus 'by ID' implicitly separates it from the sibling search_accounts, so an agent can route correctly without opening a schema.

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

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

Usage is only implied: the tool takes an ID, so it is for looking up an account you already have the identifier for, as opposed to search_accounts which finds accounts by criteria. No explicit when-to-use, when-not-to-use, or prerequisite (e.g., how to obtain an account_id) is stated.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose the key trait — 'Read-only report' — which is the main safety signal an agent needs. It says nothing about scope filtering (org/period), rate limits, or data freshness, so the disclosure is partial rather than rich.

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

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

A single compact sentence with the brackets enumerated inline and the safety trait appended at the end. Nothing is redundant and the resource is front-loaded.

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

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

For a zero-parameter report with no annotations and no output schema, the description covers purpose, output content (the five aging brackets), and safety. It stops short of specifying the reporting period or the granularity of the returned amounts, but it is otherwise sufficient to call correctly.

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

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

The tool takes zero parameters, so there is no parameter semantics burden to carry; the baseline of 4 applies. The description's enumeration of brackets is about output content, not inputs.

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

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

States a specific verb ('Get') and resource ('accounts-payable aging brackets') and defines exactly what the report measures: how much is owed to vendors and how overdue. By framing the scope as amounts owed to vendors (payables), it implicitly separates itself from the sibling get_ar_aging, which covers receivables.

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

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

The description implies the reporting use case (understanding vendor obligations by overdue bucket) but never states when to call this versus get_ar_aging, get_trial_balance, or the search_* tools. No prerequisites or exclusions are given, so usage must be inferred from the name.

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

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

With no annotations provided, the description carries the full behavioral burden, and 'Read-only report' does substitute for the missing readOnlyHint, which is genuinely useful. However, it says nothing about scoping (whole organization vs. filtered), permissions required, or whether results are period-dependent, leaving behavioral gaps the annotations would normally cover.

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

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

A single sentence plus a short qualifier, front-loaded with the resource and followed by the bracket detail. Every clause earns its place and there is no redundancy.

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

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

For a zero-parameter read-only report with no output schema, the description usefully enumerates the return brackets so the agent knows what it will get back. The only shortfall is the absence of any statement about scoping or time period, which matters for an aging report.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The bracket list in the description describes output shape rather than parameter meaning, so there is nothing further for the description to add here.

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

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

The description names a specific verb ('Get') and resource ('accounts-receivable aging brackets') and enumerates the exact brackets returned, so the agent knows precisely what report this is. It does not explicitly name sibling get_ap_aging as the counterpart, but the 'accounts-receivable' scope makes the distinction self-evident.

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

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

Usage is implied by the resource itself — an aging report is fetched when overdue receivables are needed — but there are no explicit when-to-use or when-not conditions and no mention of alternatives such as get_ap_aging or get_trial_balance. No exclusions or prerequisites are given.

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

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

With no annotations provided, the description carries the full burden, and 'Read-only' is a genuine, useful disclosure about the operation's safety profile. However, it says nothing about permissions, error behavior when the ID doesn't exist, or any rate considerations, leaving substantial gaps for an un-annotated tool.

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

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

Two terse sentences with zero waste; the purpose is front-loaded and the read-only trait follows immediately. Nothing could be trimmed without losing 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 minimal one-parameter lookup with no output schema, the description is nearly sufficient: it scopes the resource, the key, and the safety profile. It stops short of describing the returned shape, though 'full details' gestures at it and no output schema constrains it.

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

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

The single 'id' parameter has 100% schema description coverage ('Bank account ID'), so the schema already documents it. The description only restates 'by ID' without adding format, type, or lookup-mechanics detail beyond the schema baseline.

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

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

States a specific verb ('Get') and resource ('a single bank account by ID'), with the 'single... by ID' scope clearly separating it from the sibling search_bank_accounts. It doesn't explicitly name the sibling, but the singular/by-ID framing makes the distinction inferable.

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

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

Usage is only implied: 'by ID' suggests you must already have the account identifier, which routes an agent away from this tool when it needs to discover accounts. No explicit when-to-use or when-not guidance, and no alternative named.

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

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

No annotations are provided, so the description carries the full burden; it does this by declaring 'Read-only', which is exactly the safety signal an annotation would have supplied. It does not go further into permissions or response format, but for a lookup tool the key behavioral trait is covered.

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

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

Two short sentences, purpose first and the read-only qualifier second. Nothing is wasted and the essential information is front-loaded.

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

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

For a one-parameter retrieval tool, the description covers what is fetched ('full details of a single imported bank transaction') and its read-only nature, which is sufficient for correct invocation. Without an output schema it could have sketched the returned shape, a minor remaining gap.

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

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

Schema description coverage is 100%, so the single 'id' parameter is already documented as 'Bank transaction ID'. The description adds only 'by ID', which confirms intent but no format or syntax beyond the schema; baseline 3 applies.

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

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

States a specific verb (Get) and resource (a single imported bank transaction) with an explicit lookup key ('by ID'), which implicitly separates it from the sibling search_bank_transactions (plural search). It does not name the sibling explicitly, but the singular/ID framing makes the distinction clear.

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

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

The phrase 'by ID' implies the tool is used when a transaction identifier is already known, and the contrast with search_* siblings is implied rather than stated. There is no explicit when-to-use/when-not guidance or named alternative.

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

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

No annotations are provided, so the description carries the behavioral burden; it helpfully discloses the return payload (line items, payment history, balance due). However, it says nothing about permissions, whether the bill must be in a certain state, or error behavior when the ID is invalid.

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

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

Two tight sentences with the action front-loaded and the return contents second. No redundant or filler text.

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

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

For a simple single-entity read tool with no annotations and no output schema, the description covers the action and the shape of the return, which is sufficient for correct invocation. Minor gaps around error/empty-state behavior keep it from a 5.

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

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

There is a single parameter with 100% schema description coverage, so the schema already documents bill_id fully. The description adds no format or type detail beyond what the schema provides, which is the expected baseline when schema coverage is complete.

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

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

States a specific verb (Get) and resource (a single bill by ID), and the word 'single' implicitly distinguishes it from the list-oriented search_bills sibling. Clear enough to route correctly, though it does not name the alternative explicitly.

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

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

The phrase 'by ID' implies you invoke this when you already have a bill_id, and listing the returned fields hints at why you'd use it over a search. But there is no explicit when-to-use guidance, no mention of search_bills as the alternative, and no prerequisites.

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

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

No annotations are provided, so the description carries the full burden; it implies a read-only lookup by using 'Get' and it discloses that the payload includes bill applications, which is genuinely useful. It says nothing about permissions, whether voided payments are returned, or error behavior for an unknown ID.

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

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

Two short sentences, zero filler, with the identity of the resource and its scope front-loaded before the return-value note.

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

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

For a single-parameter getter with no output schema, the description covers the essentials: what is fetched, by what key, and roughly what comes back. The remaining gap is the relationship to the search/create/void siblings in the same family.

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

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

Only one parameter (payment_id) and schema description coverage is 100%, so the schema already defines it fully. The description adds no format, type, or sourcing guidance beyond what the schema states, which matches the baseline for a fully documented parameter.

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

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

States a specific verb and resource ('Get a bill payment by ID') and tags it '(AP)', which separates it from AR-side siblings. It does not explicitly contrast with the adjacent get_payment or search_bill_payments, so an agent still has to infer the boundary.

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

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

There is no guidance on when to use this versus search_bill_payments (to find an ID first) or get_payment (a different payment object). The description never names an alternative or a precondition beyond having an ID.

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

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

No annotations exist, so the description carries the full behavioral burden. It does usefully disclose the safety profile ('Read-only dashboard report'), which substitutes for a readOnlyHint, but says nothing about the period covered, refresh/data-freshness behavior, or cost of the aggregation.

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

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

Two short sentences with the subject front-loaded and no filler. The second sentence adds the read-only constraint rather than restating the first.

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

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

For a zero-parameter, read-only tool with no annotations and no output schema, the description covers what it returns at a high level and its safety profile. It leaves the reporting period/time window unstated, which is the main remaining gap.

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

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

The tool takes zero parameters, so there are no parameter semantics to document; the baseline for a no-parameter tool is 4. Nothing in the description misleads about inputs.

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

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

The description names a specific resource (business-health summary) and clarifies the payload as composite financial health indicators and scores for the organization. The word 'composite' distinguishes it from single-metric siblings like get_profit_and_loss and get_cash_position, though it does not name them explicitly.

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

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

'Read-only dashboard report' implies this is a top-level overview used before drilling into specific financial reports, but no explicit when-to-use or when-not-to-use guidance is given relative to the many sibling report tools. Usage is inferable rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses 'Read-only report,' which rules out mutations and clarifies the safety profile, but it adds no further context such as required permissions, data freshness, or whether inactive accounts are included.

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

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

Two sentences with zero waste: the core purpose is front-loaded, followed by a brief safety note. Every phrase earns its place.

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

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

For a simple read-only report with one optional parameter and no output schema, the description covers purpose, scope, and read-only nature adequately. It could mention the shape of the returned cash position (e.g., balances by account), but the phrase 'across GL cash accounts and bank accounts' implies that breakdown.

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

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

Schema description coverage is 100%, so the asOfDate parameter is fully documented in the schema. The description mirrors this with 'as of a date' but adds no syntax or format details beyond what the schema already provides.

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

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

States a specific verb ('Get'), resource ('current cash position'), scope ('across GL cash accounts and bank accounts'), and timing ('as of a date'). This clearly differentiates it from siblings like get_bank_account (single account) and get_trial_balance (full ledger), but it does not explicitly name an alternative tool.

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

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

No guidance on when to use this tool versus alternatives such as get_trial_balance, get_bank_account, or search_bank_transactions. The 'Read-only report' phrase signals safety but not selection criteria or exclusions.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it enumerates the exact return statuses (connected | unauthenticated | disconnected), states what credential/base-URL information is included, and gives a security guarantee that secrets are never returned. This is exactly the kind of read-only safety and return-shape context an agent needs for a connectivity tool.

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

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

Three tightly packed sentences: purpose, return contents plus security guarantee, then usage directive. Front-loaded with the core purpose and no filler.

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

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

Because there is no output schema, the description must explain return values — and it does (status enum, credential flag, base URL, no secrets). Combined with the call-first guidance, nothing an agent needs to invoke this correctly is missing.

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

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

The tool takes zero parameters and the schema is an empty object, so there is no parameter semantics for the description to explain. Baseline score of 4 applies for a no-parameter tool.

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

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

States a specific verb ('Report') and resource (connectivity of the KikoBooks MCP server to an organization), and is clearly distinct from every sibling tool, which are all domain CRUD/search/analytics operations. An agent can identify this as the health-check tool without opening any schema.

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

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

Explicitly instructs to 'Call this first to confirm connectivity before other tools,' establishing both when to use it and its ordering relative to all siblings. No alternative tool exists for this purpose, so no when-not clause is needed.

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

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

With no annotations, the description carries the full disclosure burden. It usefully states what comes back (line items and application history), but says nothing about error behavior for invalid IDs, permissions, or the read-only nature beyond the verb 'Get'.

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

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

Two short sentences, purpose front-loaded, and the return contents appended without filler. Every clause earns its place.

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

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

For a one-parameter getter with no output schema, describing the returned payload (line items, application history) fills the main gap. Missing only edge-case behavior such as invalid-ID handling, which is a minor omission at this complexity.

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

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

Schema description coverage is 100% and the single parameter is already documented as 'The credit memo ID to retrieve'. The description's 'by ID' adds nothing beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource (Get a credit memo) plus the lookup key (by ID), making the operation unambiguous. It does not explicitly contrast itself with the sibling search_credit_memos, so it falls short of a 5.

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

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

The phrase 'by ID' implies the tool is for direct retrieval when an identifier is already known, which distinguishes it implicitly from search_credit_memos. No explicit when-to-use, prerequisites, or fallback guidance is offered.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the return shape (contact info, addresses, balance), which is useful, but says nothing about permissions, behavior on an invalid/missing ID, or whether soft-deleted customers are returned.

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

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

Two short sentences, zero filler, with the lookup action front-loaded and the return summary second. Every clause earns its place.

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

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

For a one-parameter read tool with no output schema, the description covers the essential return fields, which compensates for the absent output schema. Minor gaps remain around error behavior and permissions, but nothing blocking for correct invocation.

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

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

Schema coverage is 100% for the single customer_id parameter, so the schema already documents type and meaning. The description's 'by ID' adds no syntax or constraint detail beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb ('Get') and resource ('customer') with a scoping qualifier ('single ... by ID'), which is enough to distinguish it from search_customers. It does not name that sibling explicitly, so the differentiation is implied rather than stated.

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

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

The 'by ID' phrasing implies this is a direct-lookup tool rather than a discovery tool, which is usable guidance. However, it never states when to prefer this over search_customers or what to do if the ID is unknown, so the usage rule is left to inference.

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

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

No annotations are provided, so the description carries the burden. 'Get' implies a safe read and the Sales-module prerequisite is genuine behavioral context, but nothing is said about behavior for unknown/unauthorized IDs or access scoping.

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

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

A single sentence, front-loaded with the verb and resource, with the field list and prerequisite appended — no filler.

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

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

With a single documented parameter and no output schema, the description usefully names the fields returned and the module prerequisite. It stops short of error/not-found behavior, but is otherwise adequate for a trivial 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?

Only one parameter and schema description coverage is 100%, so the schema already documents deal_id fully ('The CRM deal ID to retrieve'). The description's 'by ID' adds no syntax or format detail beyond the schema; baseline 3 applies.

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

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

States a specific verb (get), resource (CRM deal), scope (single, by ID), and enumerates the returned detail (value, stage, pipeline, linked lead/customer). The 'single ... by ID' framing cleanly distinguishes it from the sibling search_deals.

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 prerequisite 'Requires the Sales module' is useful, and 'by ID' implies the caller must already hold an ID. But it never states when to prefer this over search_deals or what to do if only a name is known, so usage is only implied.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses that the operation is 'Read-only' and mentions the returned detail includes allocated payments, but it does not cover permissions, error behavior, or other operational constraints.

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

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

The description is a single front-loaded sentence with no wasted words. The key operation and resource come first, followed by return detail and read-only status.

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

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

For a simple one-parameter get tool with no output schema, the description is largely complete: it identifies the resource, lookup key, returned scope, and read-only nature. It could be strengthened by explicitly pointing to search_deposits for lookup workflows, but that is a minor gap.

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

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

Schema description coverage is 100% and the only parameter is clearly documented as 'Deposit ID' in the schema. The description reinforces that the ID identifies a single bank deposit but adds no format, range, or other semantic detail beyond the schema.

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

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

The description states a specific verb ('Get'), a specific resource ('single bank deposit'), the lookup key ('by ID'), and additional returned content ('including its allocated payments'). This clearly distinguishes it from list/search siblings such as search_deposits.

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

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

The description implies the tool should be used when a single deposit is needed by ID, but it does not explicitly say when to use it versus search_deposits or other get/deposit tools. There are no exclusions or alternative-routing instructions.

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

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

No annotations are present, so the description carries the full burden and does provide meaningful behavioral context: Bookkeeping and AI are always available, while CRM, Proposals, and Workflow are mandatory or opt-in depending on organization type. It also discloses the intended usage constraint. It stops short of explicitly stating that it is a read-only operation or describing the response shape, but the added context is substantial.

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

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

Front-loads the purpose, then gives important availability context, then ends with a clear actionable instruction. The single paragraph is dense but earns every clause; nothing is redundant or misplaced.

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

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

For a no-argument capability-listing tool with no output schema or annotations, the description gives an agent everything needed to call it correctly and interpret its role: what it returns, which modules are always available, which are conditional, and the policy for using disabled module 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?

The tool takes zero parameters, so the baseline is 4. The description appropriately does not add parameter-level details because none exist, and the empty schema is fully consistent with 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?

States a specific verb ('List') and resource ('modules and capabilities enabled for the connected organization'), making the scope unambiguous. It also frames itself as a prerequisite capability check, which distinguishes it from the many search/get/create action tools 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?

Explicitly instructs when to call it: 'call this before offering any sales, proposal, or job/workflow action.' It also states the consequence of not doing so ('if a module is not enabled, do not attempt its tools') and explains the organizational conditions (CA vs CB) that determine module availability.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the safety profile ("Read-only report"), which is genuinely useful given the absence of readOnlyHint, but it says nothing about the default period covered, whether all accounts are included, or whether the periodBucket filter changes scope.

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, both front-loaded: the first defines the output, the second defines the safety profile and purpose. No filler, no restatement of the tool name.

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

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

For a one-optional-parameter read-only report, the description conveys the shape of the result (a breakdown grouped by category/account) in lieu of an output schema, and flags the read-only nature in lieu of annotations. Only the default time window and aggregation granularity remain unstated, which is a minor gap.

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

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

Schema description coverage is 100% and the single periodBucket parameter is already documented as an optional integer filter in the schema. The description adds no information about the parameter (it never mentions period filtering), so baseline 3 applies.

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

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

States a specific verb (Get) and resource (expense breakdown grouped by category/account), so the agent knows exactly what is produced. It does not explicitly distinguish itself from its close sibling get_income_by_category or the other report tools (get_trial_balance, get_profit_and_loss), though the word 'expense' does most of the work implicitly.

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?

"Read-only report for understanding where money is being spent" hints at the analytical use case, which is implied usage guidance. It never states when to pick this over get_income_by_category or get_profit_and_loss, and there are no prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden, and it does supply the key safety fact ('Read-only'). Beyond that it says nothing about authentication, pagination, or error behavior (e.g., what happens if the ID does not exist), so the disclosure is minimal.

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

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

One tight sentence with the primary intent front-loaded, followed by a short safety tag. No filler or repetition of the tool name.

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

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

For a simple single-parameter getter with no output schema, the description is nearly complete: it names the resource and even flags the returned depreciation settings. It only lacks detail on failure modes when the ID is not found.

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

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

Only one parameter exists and schema coverage is 100% ('Fixed asset ID'), so the schema already does the work. The description's 'by ID' is consistent but adds no syntax or format detail beyond the schema.

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

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

States a specific verb (Get), resource (fixed asset), and scope (a single one, by ID), plus the notable content it returns (depreciation settings). An agent can immediately distinguish it from the sibling search_fixed_assets.

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

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

The phrase 'a single fixed asset by ID' implies this is the follow-up to a search result, but there is no explicit statement of when to use it versus search_fixed_assets or when not to use it. Usage is inferable but not spelled out.

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

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

With no annotations, the description carries the full burden, and it does disclose the read-only safety profile ('Read-only report'). However, it says nothing about return format, pagination or ordering, permission requirements, or precisely what the breakdown contains, and there is no output schema to compensate.

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

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

Two short sentences, zero filler, with the core action front-loaded and the read-only/intent qualifier trailing. Every sentence earns its place.

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

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

For a simple single-parameter, read-only analytic tool with no output schema, the description covers the action, the grouping dimension, and the safety profile adequately. It leaves the exact shape of the report and its relationship to sibling financial reports unspecified, which is a minor gap rather than a blocking one.

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

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

Schema coverage is 100% and there is only one optional parameter, so the schema already documents periodBucket. The description adds no meaning about the bucket's units, allowed values (there are no enums), or what the default view is, so baseline 3 applies.

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

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

States a specific verb and resource ('Get the income/revenue breakdown') plus the grouping dimension ('by category/account'), which distinguishes it from the many search_* siblings. It does not name the obvious adjacent sibling get_expense_by_category or get_profit_and_loss, so differentiation is only implicit through the 'income/revenue' scope.

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

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

'For understanding revenue sources' implies the use case but gives no when-to-use rule, no exclusions, and no routing toward alternatives such as get_profit_and_loss or get_expense_by_category. Usage is inferable but not stated.

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

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

No annotations are provided, so the description carries the full burden; 'Get' makes the read-only nature clear and it goes beyond that by describing the returned payload (line items, payments, credits, balance due), which compensates for the absent output schema. It omits permission requirements and error behavior for a missing ID, keeping it from a 5.

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

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

Two tight sentences with the lookup key front-loaded and the return summary second; every clause earns its place with no redundancy.

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

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

For a one-parameter read tool with no output schema, the description covers identity and return shape adequately. Sibling routing (search_invoices) and failure behavior are the remaining minor gaps.

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

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

Schema description coverage is 100% with a single well-documented invoice_id parameter, so the baseline is 3. The description's 'by ID' corroborates the schema but adds no format, type, or sourcing detail beyond it.

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

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

States a specific verb and resource (get a single invoice) plus the lookup key (by ID) and the source system, so the agent can distinguish it from search_invoices and update_invoice without opening the schema. It stops short of explicitly naming the sibling search tool, so it is not a 5.

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

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

The phrase 'by ID' implies the tool is for direct retrieval when an identifier is already known, but the description never says when to prefer it over search_invoices or what to do if the ID is unknown. Usage is inferable but not stated.

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

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

No annotations provided, so the description carries the full burden. It discloses that it returns 'full item details including pricing and account mapping', which is genuinely useful context about the return shape even absent an output schema. But it doesn't state error behavior (e.g., non-existent ID), auth/permission needs, or whether it's read-only — though a 'Get' strongly implies read-only.

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 waste, front-loaded with the verb+resource+scope. Every phrase earns its place, with return content disclosed second.

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

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

For a one-parameter read tool this is nearly sufficient, but with no annotations and no output schema, the description is the only source of behavioral info yet omits error handling and permission requirements. Return content is partially described, which helps.

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

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

Schema description coverage is 100% — the single item_id parameter is fully documented in the schema as 'The Item ID to retrieve'. Description adds no parameter specifics beyond restating that ID is required. Baseline 3 when schema does the heavy lifting.

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

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

States a specific verb (Get) and resource (single product/service item by ID from KikoBooks). Clearly distinguishes from sibling search_items (search vs single fetch), though it doesn't explicitly name the alternative like the highest-scoring examples do.

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

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

Usage is implied — retrieve one item when you have its ID. However, no explicit when/when-not guidance and no mention of search_items as the alternative for listing/finding items without an ID. Adequate but with clear gap.

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

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

No annotations are provided, so the description carries the burden. It adds useful context by disclosing the Workflow module dependency and the returned detail fields, and 'Get' signals read-only. It does not cover error behavior when the ID is unknown or whether jobs from other modules are visible.

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

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

Two tight clauses with zero waste: the core action and scope come first, and the module prerequisite follows. Every phrase earns its place.

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

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

For a single-parameter get-by-ID tool with no output schema or annotations, the description covers the resource, the returned fields, and the module prerequisite. Only error/not-found behavior is left unspecified, which is a minor gap.

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

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

Schema description coverage is 100% for the single job_id parameter, so the schema already documents its meaning and type. The description adds no format or constraint detail beyond that, matching the baseline for fully covered schemas.

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

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

States a specific verb and resource ('Get a single job by ID') and enumerates the detail returned (status, customer, dates, billing). This clearly separates it from search_jobs and list_job_tasks, 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 'Requires the Workflow module' clause is a genuine prerequisite, but there is no explicit statement of when to use this versus search_jobs (single known ID) or list_job_tasks. Usage is only implied by 'single job by ID'.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses return content (debit/credit lines, posting status, audit hash), but says nothing about read-only nature, permissions, or error behavior for a missing/voided entry.

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

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

Two short sentences, front-loaded with the action and identifier, then the return contents. No filler or redundant phrasing.

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, describing the returned fields is the right compensating detail, and it covers the essentials for a simple single-entity fetch. The absence of any note about missing entries or permissions is a minor gap.

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

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

Only one parameter, and schema description coverage is 100% ('The Journal Entry ID to retrieve'), so the schema already documents it fully. The description's 'by ID' adds no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

The description states a specific verb and resource ('Get a single journal entry by ID'), and the word 'single' implicitly contrasts with search_journal_entries. It is clear but never names the sibling tools it must be distinguished 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?

There is no when-to-use guidance, no mention of search_journal_entries as the way to discover IDs, and no prerequisites or exclusions. Usage is only inferable from the phrase 'by ID'.

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

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

No annotations are provided, so the description carries the burden. It usefully discloses the module prerequisite ('Requires the Sales module') and implies read-only via 'Get', but says nothing about error behavior for missing/invalid IDs or any access constraints beyond the module.

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

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

One sentence, front-loaded with the core action, then the returned detail, then the prerequisite. Zero wasted words.

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

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

For a simple single-entity getter with no output schema, the description covers the resource, what detail is returned (contact info, status, source, linked customer), and the module prerequisite. It is nearly complete, though it lacks any note on missing-record behavior.

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

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

Schema description coverage is 100% for the single lead_id parameter, so the schema already documents it fully. The description's 'by ID' adds no syntax or format detail beyond what the schema provides, making the baseline 3 correct.

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

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

States a specific verb (Get) and resource (CRM lead) with clear scope ('single ... by ID'), which implicitly separates it from search_leads. However it never names the sibling alternative, so differentiation relies on inference.

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

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

Usage is implied by 'by ID' (lookup of one known lead vs. browsing), and the Sales module prerequisite is stated, but there is no explicit when-to-use guidance or pointer to search_leads for discovery.

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

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

No annotations are supplied, so the description carries the burden, and it does disclose 'Read-only' — a meaningful safety signal. Beyond that it says nothing about authentication requirements, caching/staleness of fiscal settings, or whether it errors when no organization is connected, which is thin for a tool with zero annotation coverage.

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

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

One sentence, front-loaded with the verb and resource, then the returned fields, then the read-only qualifier. No filler and nothing buried.

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

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

With no output schema, the description usefully enumerates what the profile contains, which is exactly what the agent needs from a zero-parameter getter. It is nearly complete, missing only confirmation of behavior on a disconnected/unauthenticated state.

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

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

The tool takes no parameters, so per the rubric the baseline is 4. The description correctly implies a single implicit scope (the connected organization) rather than accepting any identifier, which reinforces why no input is needed.

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

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

The description names a specific verb ('Get') and resource ('the connected organization's profile') and enumerates the fields returned — legal name, currency, fiscal settings, enabled modules. It does not, however, differentiate itself from the sibling get_enabled_modules, which overlaps with the last field it advertises.

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

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

The description contains no when-to-use guidance at all. It never says when this profile fetch is preferable to get_connection_status or get_enabled_modules, nor whether it should precede other org-scoped operations, leaving the agent to infer routing from names alone.

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

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

No annotations are provided, so the description carries the full burden. 'Get' and 'Returns' imply a non-mutating read, and it usefully discloses that allocations to invoices are included, but it says nothing about behavior when the ID is not found, permission requirements, or whether results are cached/limited.

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