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

No annotations are provided, so the description carries the full burden. It discloses the critical post-success behavior (output the exact returned text verbatim), which is a valuable behavioral trait. However, it omits other aspects like permissions, side effects, or response format beyond the verbatim instruction. The description does not contradict annotations (none exist).

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

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

The description consists of two sentences. The first is concise and purposeful, but the second is long and detailed, containing the critical output instruction. While not excessively verbose, the structure could be improved by separating the behavioral instruction into a more structured format. It is still reasonably efficient.

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

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

For a mutation tool with 9 parameters, no annotations, and no output schema, the description is insufficient. It does not explain what happens on success beyond the verbatim output instruction, nor does it describe prerequisites, parameter meanings, or the overall invoice creation process. An agent would lack essential context to correctly invoke the tool.

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

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

Schema description coverage is only 11% (one parameter has a description). The tool description adds no information about parameters, leaving the agent to infer meanings from names alone. It fails to compensate for the low schema coverage, which is a significant gap for a 9-parameter create tool.

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

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

The description clearly states the tool creates a freight/transport invoice, distinguishing it from sibling creation tools like create_sales_invoice or create_purchase_invoice. The verb 'create' and resource 'freight/transport invoice' are specific and unambiguous.

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

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

The description implies usage for freight/transport scenarios via the resource name, and the sibling context reinforces this distinction. However, it does not explicitly state when not to use this tool or mention alternatives, leaving some room for interpretation.

Agents often have multiple tools that could apply. Explicit usage 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 only that the operation is create-only, but says nothing about idempotency, side effects, validation requirements, permissions, or what happens on duplicate records.

Agents need to know what a tool does to the 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 deliver the core purpose and the create-only constraint with zero wasted words. 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 9-parameter creation tool with no output schema and no annotations, this description is too thin. It lacks guidance on how to identify the counterparty or bank ledger, what 'reference' means, and what the expected return or error behavior is.

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

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

Schema description coverage is only 44%, yet the description adds no parameter-level guidance. It does not explain the relationship between counterparty_id and counterparty_name, between bank_name and bank_ledger_id, or which fields are needed beyond the two required ones.

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

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

The description uses a specific verb+resource ('Record a payment voucher') and clarifies the direction of money flow ('money paid to vendor or expense'), which distinguishes it from sibling tools like create_receipt. 'CREATE ONLY' further disambiguates it as an insert-only operation.

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

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

'CREATE ONLY' implies it should not be used for updates, and the '(money paid to...)' parenthetical hints at the outbound-payment context. However, it does not explicitly mention alternatives or state when to prefer create_receipt or invoice tools over this one.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only states 'CREATE ONLY,' which gives a limited behavioral constraint, but it does not disclose side effects like stock movement, ledger postings, duplicate handling, or required authorization—critical 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?

The description is extremely brief, front-loaded with the core action, and contains no filler. 'CREATE ONLY' is a useful disambiguation that justifies 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?

Given seven parameters, three required, no output schema, and low schema coverage, the description is too sparse. It does not explain how stock_lines should be structured, how party is identified, what response to expect, or whether any checks are performed. The tool is complex enough that an agent would need more guidance.

Complex tools with many parameters or behaviors need more documentation. 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 43%, below 50%, so the description should compensate for undocumented parameters. It does not elaborate on any parameter, including key ones like stock_lines, party_id vs party_name, or company_id. The description adds no parameter-level meaning 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 ('record') and resource ('inward purchase invoice from a supplier'), and 'CREATE ONLY' clearly limits the operation. This distinguishes it from sibling tools like create_sales_invoice and create_logistic_invoice.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 entering a new supplier purchase invoicement and 'CREATE ONLY' explicitly forbids updates. However, it does not describe when alternative creation tools might be preferable, nor does it mention any prerequisite such as verifying the supplier or stock items first.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds 'CREATE ONLY' as a constraint, but does not mention prerequisites, side effects, idempotency, auth requirements, or what happens after creation. For a mutating tool this is a significant transparency gap.

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

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

The description is very short and front-loads the core purpose. The 'CREATE ONLY' repetition is slightly redundant with 'Record', but overall the text wastes no 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?

Given 9 parameters, no output schema, and no annotations, this minimal description is not enough for an agent to confidently invoke the tool. Critical context about required relationships, ledger selection, and expected behavior is missing.

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

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

Schema coverage is only 44%, and the description adds almost no parameter-level meaning beyond 'money received into bank/cash.' It does not clarify how fields like bank_ledger_id, counterparty_id, reference, or company_id relate to receipt creation, so the low schema coverage is not compensated.

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

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

The description states a specific action ('Record') and resource ('receipt voucher'), and clarifies the domain as money received into bank/cash. This distinguishes it from sibling tools like create_payment and create_sales_invoice, though it does not explicitly name them.

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

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

The phrase 'money received into bank/cash' provides clear context for when the tool is appropriate, but there is no explicit guidance about when not to use it or which sibling alternative to pick. The usage context is implied rather than explicitly contrasted with create_payment.

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

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

With no annotations, the description carries the behavioral disclosure burden. It provides meaningful side-effect information: posts balanced accounting ledger transactions, auto-assigns sequential invoice numbers, and specifies exact verbatim output behavior on success. This goes well beyond a basic mutation description, though it omits details like failure behavior or 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?

The description is front-loaded with the core purpose and then provides important behavioral context and a critical output instruction. The output instruction is verbose but earns its place because it directly shapes agent behavior. The standalone 'CREATE ONLY.' is slightly redundant but short.

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

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

The description covers purpose, side effects, numbering behavior, and output handling, which is a solid baseline for a create tool. However, given the absence of an output schema and low parameter coverage, it leaves gaps around return structure, parameter semantics, and edge cases that an agent would need for fully reliable invocation.

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

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

Schema description coverage is only 43%, so the description must compensate for undocumented parameters. It adds little beyond the schema for most fields: only invoice_number's auto-assignment is highlighted. Parameters like date, party_id/party_name, notes, and stock_lines field semantics remain unexplained.

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

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

The description opens with a specific verb and resource: 'Create a GST sales invoice with stock items.' This clearly identifies what the tool does and differentiates it from siblings like create_purchase_invoice or create_service_outward by the 'sales' and 'stock items' 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?

The phrase 'CREATE ONLY' implies the tool should not be used for updates or other operations, and the sales-invoice naming implies the general use case. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It adds 'CREATE ONLY,' which usefully signals the operation is limited to creation, but it does not disclose side effects, required permissions, duplicate handling, or response behavior for a mutation tool.

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

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

The description is a single, front-loaded sentence with zero filler. It states the action, resource, examples, and constraint ('CREATE ONLY') in the most economical way possible.

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

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

For a tool with 7 parameters, no output schema, no annotations, and many sibling create tools, the description is too sparse. It does not explain required inputs, service line structure, validation rules, or what distinguishes this from similar creation tools beyond 'inward service bill.'

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

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

Schema description coverage is only 43%, and the description does not compensate. It provides examples of service types, which hints at service_lines, but it never explains key parameters like company_id, vendor_invoice_no, date, party_id, or amount semantics beyond what the schema already states.

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

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

The description names a specific verb and resource: 'Record an inward expense / service bill' with concrete examples (rent, audit fees, freight, AMC). The word 'inward' plus examples distinguishes it from sibling tools like create_service_outward and create_purchase_invoice.

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

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

The description implies when to use it: for inward service expenses rather than outward services or goods purchases. However, it never explicitly names alternatives or states when not to use this tool, so an agent must infer routing from the sibling tool list and context.

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

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

With no annotations, the description carries the full burden and does disclose a significant behavioral trait: on success the agent must output the exact returned text verbatim, without converting to tables or adding markdown summaries. This is genuinely useful beyond what any schema could convey. It omits permission requirements and failure behavior, but the post-success output contract 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?

Two sentences, with purpose front-loaded in the first. The CRITICAL instruction is somewhat verbose ('without converting it into tables or adding extra markdown summaries, so the user can easily copy and send...') but the redundancy reinforces a behavior that is easy to get wrong. Overall efficient with no filler.

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

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

For a create tool with six parameters, no annotations, no output schema, and 33% schema coverage, this description is incomplete. It implies the tool returns a copyable notification message but never specifies required inputs, alternatives, side effects, or failure handling. An agent would still need to inspect the schema and siblings to invoke it correctly.

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

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

Schema description coverage is only 33%, so the description must compensate for the six underspecified parameters, but it provides none. It does not clarify that company_id and service_lines are required, what sac_code or gst_rate mean within service_lines, or the format of date beyond the schema's YYYY-MM-DD hint. The phrase 'professional services, maintenance, etc.' vaguely hints at service_types but adds no concrete parameter 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 ('Create') and resource ('service billing invoice to clients for professional services, maintenance'). The phrase 'to clients' distinguishes it from the sibling create_service_inward, and 'service billing invoice' differentiates it from sales/purchase invoices. Purpose is immediately 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 only guidance is 'CREATE ONLY,' which is a scope constraint rather than usage direction. The description never states when to choose this tool over create_service_inward, create_sales_invoice, or other create siblings, nor does it mention prerequisites such as needing a party_id or existing company_id.

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

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

With no annotations, the description carries the burden of disclosing behavior. 'Get list' implies a read-only query, but the description does not mention pagination, ordering, filtering, or whether all groups are returned at once. This is partially transparent but incomplete.

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

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

A single, tightly worded sentence that front-loads the action and includes useful examples. No redundancy or unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 simple one-parameter read-only list tool, so the description is mostly sufficient. However, it lacks explicit parameter clarification, usage guidance, and any output-shape information, leaving some room for ambiguity.

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

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

Schema description coverage is 0%, and the description never mentions company_id or its role. The parameter is self-explanatory and required, so an agent can likely infer it, but the description adds no additional meaning 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 clearly states a specific action ('Get list') and resource ('chart of account groups'), and the examples (Sundry Debtors, Bank Accounts) make the object concrete. It does not explicitly differentiate from sibling tools, but the resource is distinct enough to be understood.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 search_ledgers or get_ledger_balance. No conditions, exclusions, or recommended contexts 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?

With no annotations, the description carries the full behavioral burden. It signals a read operation ('Get') and lists report contents, but it fails to disclose that report_type controls which portion is returned, that the default is summary, or what the response looks like. The claim of a 'complete' snapshot conflicts with the schema's summary default.

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

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

The description is a single front-loaded sentence with no filler or redundancy. The word 'complete' is potentially misleading, but structurally it is efficient and easy to parse.

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

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

For a tool with no output schema and no annotations, the description omits important operational details: report_type behavior, default value, response shape, and how this differs from get_trial_balance or get_ledger_statement. An agent could easily call it with defaults and receive only a summary while believing it requested complete statements.

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

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

The schema already documents as_on_date and report_type (67% coverage). The description adds high-level report components like Net Profit/Loss and Balance Sheet, but it does not clarify how report_type selects among them or explain company_id beyond what the name implies.

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

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

The description uses a specific verb ('Get') and a clear resource: financial statements for a company as of a specific date, listing the included statements. It does not explicitly distinguish this from sibling tools like get_trial_balance or get_ledger_statement, but the resource is distinctive enough.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 get_trial_balance or get_ledger_statement, and no exclusions are provided. The phrase 'as on a specific date' implies a use case, but it never states why one would choose this over sibling report tools.

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

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

No annotations are present, so the description carries the full behavioral disclosure burden. It does disclose the output composition and that results are grouped 'per asset ledger,' which is useful, but it does not mention pagination behavior, date filtering effects, permissions, or empty-result handling. This is minimal but not misleading.

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

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

The description is a single sentence that front-loads the resource and then adds a focused parenthetical list of return components. There is no fluff or redundancy; every phrase contributes meaningful 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 read-only listing tool with no output schema, the description covers the main return components and grouping adequately. It omits return format details and edge cases, but the schema handles filtering and pagination defaults, making the overall package reasonably 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 schema already documents limit, ledger_id, and as_on_date, giving 75% coverage. The description adds no parameter-level detail beyond the schema, and company_id is self-evident from context. This meets the baseline but does not elevate it.

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

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

The description uses a specific verb ('Get') and names a concrete resource ('fixed asset register & depreciation summary'), then enumerates the exact components returned (opening balance, additions, disposals, depreciation, closing balance). This clearly differentiates it from the sibling tool get_fixed_asset_transactions, which is about individual transaction records rather than the register summary.

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

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

The description implies when to use the tool: whenever a fixed asset register or depreciation summary is needed. However, it does not explicitly contrast it with get_fixed_asset_transactions or state when the transaction-level tool should be preferred, leaving routing largely to inference.

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

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

With no annotations provided, the description carries the full burden of disclosure. It names the returned attributes and 'Get' implies a read-only operation, but it does not explicitly state a safe/read-only nature, pagination behavior, ordering, or error handling. It adds some behavioral context but leaves significant gaps uncovered.

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

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

The description is a single sentence that front-loads the verb and object and then provides the concrete scope and output fields. Every word contributes value, and there is no repetition of the tool name or schema 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?

The tool has 6 parameters but only one required, and 83% schema coverage plus the short description give enough for a competent agent to call it. The description covers what the log contains while the schema documents all filters; lacking is any comparison to sibling tools or output shape, but this is not critical given the high schema coverage.

Complex tools with many parameters or behaviors need more documentation. 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 83%, and the parameter descriptions largely speak for themselves (limit, to_date, from_date, ledger_id, transaction_type). The tool description names output fields (vendor, invoice number, amounts, dates) but adds no meaning to the input parameters beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description states a specific verb (Get), resource (log of fixed asset transactions), and explicitly enumerates the transaction types (purchases, sales, disposals) and data fields (vendor, invoice number, amounts, dates). It clearly distinguishes from siblings like get_fixed_assets, which would return the asset list rather than the transaction log.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 purpose statement implies when to use the tool (when you need a log of fixed asset purchases/sales/disposals), and the schema gives filtering options. However, there is no explicit mention of when not to use it or what alternatives like get_fixed_assets or get_ledger_statement are for, leaving the selection to inference.

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

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

With no annotations, the description must carry the behavioral burden. It transparently describes what the tool returns, including the major invoice components. However, it does not disclose behavior for absent IDs, error handling, authentication needs, or whether the operation is strictly read-only beyond the conventional 'get' semantics.

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

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

The description is a single, well-structured sentence with no filler. It front-loads the core action and then lists the specific data returned, which is appropriately sized for a simple retrieval tool.

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

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

The description adequately covers the tool's output contents, but not the full context needed for a correct call. With no output schema and no annotations, the missing explanation of how to specify the invoice—and the odd required/optional parameter mix—leaves a meaningful gap, though the tool remains usable if the agent infers the intended identifiers.

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

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

Schema description coverage is only 67%, and the description adds no parameter-level meaning. It does not explain that company_id is required, nor clarify that the invoice should be identified via invoice_id or invoice_number. Because both identifier fields are optional in the schema, an agent could mistakenly call with only company_id despite the description promising a specific invoice.

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

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

The description clearly identifies the action ('Get full details') and the resource ('a specific invoice'), and enumerates the returned content (line items, rates, quantities, taxes, grand totals). It is distinguishable from the sibling search_invoices because this is about full detail of one invoice rather than searching, though it does not explicitly name the alternative.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'of a specific invoice' implies the tool should be used when an agent already has an invoice in mind and needs complete details. However, it does not explicitly state when to prefer this over search_invoices, nor does it mention any prerequisites or exclusions, so the 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 must carry the behavioral burden itself. 'Get' correctly implies a read-only operationchen, and 'real-time' adds useful context about data freshness. However, it does not disclose failure modes, whether cached results are possible despite the claim, or what happens when both name and ID are provided.

Agents need to know what a tool does to the 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, tightly written sentence with no redundancy. The core action and resource appear first, and the lookup method is stated efficiently. It earns its place with no 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 low-complexity lookup tool with three parameters and no nested objects, the description plus schema is mostly complete. The lack of an output schema is partially mitigated by the description saying the tool returns a 'balance.' It could note the return shape or clarify the relationship among ledger, party, and member, but these are 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?

The schema already documents ledger_id and ledger_name, and the description's 'by name or ID' reinforces those mappings. The required company_id is not explained, but its purpose is reasonably inferable from the name. The description adds little beyond the schema, and schema coverage is moderate at 67%.

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

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

The description names a specific verb and resource: 'Get real-time balance' and identifies the target as a ledger/party/member. It also indicates lookup by name or ID, distinguishing it from statement-related tools like get_ledger_statement by focusing on 'balance' rather than transaction history. It does not explicitly name sibling alternatives, so it stops short of a 5.

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

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

There is no guidance on when to prefer this tool over get_ledger_statement, search_ledgers, or other balance-related tools. The usage context is only implied (use when you need a current balance), with no mention of prerequisites, exclusions, or 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses one useful trait, 'with running balances', but does not state read-only behavior, authentication requirements, pagination behavior, or any side effects. This is insufficient for a data-fetch tool with no annotation support.

Agents need to know what a tool does to the 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, focused sentence with no filler. Every word contributes to the core meaning.

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

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

With 6 parameters, no output schema, and no annotations, a one-line description is too thin. It omits which parameter identifies the entity, the default date range, pagination/limit behavior, and any indication of the response shape beyond 'running balances'. The required company_id is also not reflected in the description.

Complex tools with many parameters or behaviors need more documentation. 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 67%, so most parameters are already documented. The description adds a conceptual link between 'party, customer, or bank' and ledger parameters, but it does not explain ledger_id, company_id semantics, or how from_date/to_date interact with limit. It adds only marginal value beyond the schema.

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

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

The description uses a specific verb ('Get') and a well-defined resource ('date-wise statement for a party, customer, or bank with running balances'). This clearly differentiates it from siblings like get_ledger_balance (a single balance vs. a statement) and search_ledgers (searching vs. retrieving a statement).

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention exclusions, preconditions, or sibling tools, so an agent must infer usage purely from the generic statement-return description.

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

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

With no annotations, the description carries the behavioral burden. It conveys that this is a read-only snapshot scoped to a company and date, and describes the result contents. However, it does not disclose defaults (e.g., as_on_date defaulting to current date, limit defaulting to 100), pagination, or response packaging.

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

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

The description is a single sentence that front-loads the verb and resource and packs in the key output dimensions. It is efficient and easy to scan, though 'full official' is slightly redundant and the content could be organized more explicitly.

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

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

For a read-only tool with four parameters and no output schema, the description provides the core invocation context: what is returned, for whom, and as of when. It is incomplete regarding sibling-tool differentiation, defaults, limits, and pagination behavior, making it adequate but not comprehensive.

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

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

Schema descriptions already cover limit, as_on_date, and fs_section, and the description reinforces their accounting context by referencing group hierarchy and balance fields. company_id has no schema description, but its role is reasonably inferable from 'for a company'. The description adds some meaning without needing to repeat parameter syntax.

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

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

The description names a specific verb and resource: 'Get full official Trial Balance snapshot for a company as on a specific date', and enumerates output content (accounts, group hierarchy, debit, credit, net balances). This clearly differentiates it from sibling tools like get_ledger_balance or get_financial_statements.

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

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

No guidance is given on when to choose this tool over alternatives such as get_financial_statements, get_ledger_balance, or search_ledgers. An agent is left to infer the selection criteria from the tool name and description alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses the access scope ('the user has access to') and implies a read operation via 'List'. It does not describe pagination, ordering, or performance characteristics, but for a simple zero-parameter list tool this is acceptable though not rich. A 3 is appropriate because the description does not actively mislead and provides some behavioral 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?

The description is two sentences with no filler. The first states the operation and scope, the second tells the agent exactly when to use it. Every word contributes to usability, and the structure 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?

Given that this is a zero-parameter discovery tool with no output schema, the description is complete enough. It states what the tool does and how to use it in a workflof sequence. The only minor omission is any mention of large result handling, but without annotations or schema constraints, this is not a barrier to correct invocation. Thus 4 is appropriate.

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

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

The schema has zero properties, so there are no parameters to describe. The '0 params = baseline 4' rule applies. The description adds no per-value details because none are needed. It fully satisfies parameter semantics requirements.

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

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

The description clearly states the tool lists all companies the user has access to. This is a specific verb and resource, and the scope is defined by 'the user has access to'. It distinguishes the tool from siblings like search_ledgers or get_invoice_details by focusing on the overall company list rather than a specific domain object.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 explicit usage guidance: 'Call this first to identify which company to work with'. This tells the agent exactly when to invoke the tool. It does not mention alternatives or when not to use it, but none of the sibling tools serve the same company-listing purpose, so this is adequate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It conveys a read-only lookup behavior and enumerates the kinds of data returned, which is helpful. However, it does not disclose behavior when no parameters are supplied, whether parameters can be combined, or the shape of the result.

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

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

A single, front-loaded sentence with no filler. Every element—lookup, jurisdiction, code types, and sample percentages—earns its place and communicates the tool's purpose efficiently.

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

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

The tool has no annotations and no output schema, so the description must do more work. It captures the core capability but omits interaction semantics such as whether `code` and `search_term` are alternatives, how `type` interacts with them, and what an empty query would return. Adequate for a simple lookup, but not fully complete.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds examples of codes and tax percentages, reinforcing meaning, but does not materially go beyond what the input schema provides. Baseline 3 applies.

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

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

The description states a specific verb ('look up') and a precise resource ('official Indian GST rates, HSN codes, SAC codes, descriptions, and tax percentages'). It clearly distinguishes this tool from the accounting/invoice siblings, which are about ledgers, invoices, and financial statements rather than tax lookup.

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

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

The description implies this tool should be used when an agent needs Indian GST rate or code information, but it never explicitly states when to use it versus alternatives or how to choose between the `code` and `search_term` parameters. Usage context is clear from subject matter but not directly articulated.

Agents often have multiple tools that could apply. Explicit usage 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 mentions search and some data fields, but it does not disclose the required company_id, default limit, date filtering semantics, or the read-only nature of the operation.

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

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

The description is a single front-loaded sentence with no filler or repetition. It efficiently states the operation and resource.

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

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

Given no output schema and no annotations, the description is too minimal. It omits the required company_id context, default and limit behavior, date range semantics, and what the search results contain. The unsupported field list further weakens completeness.

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

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

Schema coverage is 80%, so most parameters are already documented, but the description adds no parameter-level meaning. The fields it lists (consignor, consignee, weight, packages, freight) do not correspond to any input schema properties, which could mislead an agent into expecting unsupported filter parameters.

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

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

The description uses a specific verb 'Search' and identifies a distinct resource: transport/delivery challans (GR dockets), with relevant fields like consignor, consignee, weight, packages, and freight. It is clear, though it does not explicitly name sibling alternatives to differentiate itself.

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

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

No guidance is provided about when to use this tool versus related siblings such as search_invoices, search_stocks, or search_ledgers. The only signal is the resource type itself, with no exclusions or 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?

No annotations are present, so the description carries the full burden. The description only says 'Search invoices by...' and does not disclose whether the operation is read-only, what kind of result objects are returned, how results are ordered, or whether it affects data in any way.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the core purpose and all key filter dimensions efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 8 parameters, one required parameter (company_id, which has no schema description), and no output schema, the description is too sparse. It does not explain what company_id means, what the response contains, or how the search behaves with empty results or large result sets.

Complex tools with many parameters or behaviors need more documentation. 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 high at 88%, so the baseline is 3 even without extra parameter explanation. The description summarizes the filter categories, but adds no new semantics beyond the schema, such as how filters combine or behave in edge cases.

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

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

The description states a clear verb ('Search'), a specific resource ('invoices'), and enumerates the supported filter dimensions. It is not a tautology, but it does not distinguish explicitly from sibling tools like get_invoice_details or search_ledgers.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 about when to use this tool versus alternatives such as get_invoice_details, which likely retrieves full details for a specific invoice. No exclusions, prerequisites, or hints about when a different search tool would be more appropriate 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 must carry the behavioral disclosure burden. It only states the search action and criteria, but does not mention auth requirements, result shape, pagination, how matches are returned, whether fuzzy matching is used, or whether this is a read-only operation.

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

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

The description is a single, tightly written sentence that front-loads the verbs and resource while fitting the main search criteria into the same sentence. There is no redundant wording or structural padding to distract from the core purpose.

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

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

With no annotations and no output schema, the description is thin for the context needed to invoke the tool correctly. It does not mention matching behavior, returned record set or its size, company scoping, or any limitations such as exact vs. partial matching. The description would be just enough if the schema and annotations were richer, but here those are absent.

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

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

Schema coverage is 50% and the description largely repeats what the schema already says about search_term ('name or flat no'). It does not explain the purpose or required role of company_id, and it does not add meaningful parameter-level semantics beyond the existing field description.

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

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

The description clearly names the verb ('Search'), the resource ('ledgers/parties/members'), and the search criteria ('by name or flat number'). It differentiates the tool from sibling search tools like search_invoices, search_stocks, and search_challans by specifying this tool searches ledger/party records.

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

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

There is no guidance on when to use this tool versus alternatives such as get_ledger_balance or get_ledger_statement. The description implies usage only from 'Search' and the resource name, but does not explain when a fuzzy name/flat search is the right choice or when a different ledger tool is preferred.

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

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

With no annotations, the description carries the full burden. It discloses useful behavioral context by stating that returned quantities are 'current' and naming the returned fields. However, it does not describe search matching behavior, pagination, company scoping, or response structure, so behavioral coverage is only partial.

Agents need to know what a tool does to the 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, compact sentence that front-loads the action and resource and includes only the essential distinguishing details. Every word earns its place, with no filler or redundancy.

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

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

For a relatively simple search tool with no output schema, the description names the key return fields and the schema covers filtering and limiting parameters. It is adequate for invoking correctly, though it could be slightly richer by noting that results form a list and how search_term matching works.

Complex tools with many parameters or behaviors need more documentation. 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 75%, with limit, category, and search_term already explained in the schema. The description does not add parameter-level meaning beyond the schema; it mostly describes output fields. The undocumented company_id is self-explanatory by name and required status, so the baseline 3 is appropriate.

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

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

The description clearly states the action ('Search') and the resource ('stock/inventory items'), then enumerates distinctive result fields: current available quantity, rates, HSN, and UQC unit. This makes it easy to distinguish from sibling search tools like search_ledgers, search_invoices, and search_challans.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 use case is implied by the phrase 'Search stock/inventory items,' so an agent can infer when to use it. However, there is no explicit when-to-use or when-not-to-use guidance, nor any named alternative or exclusion, leaving the decision to the agent's inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description states what fields can be updated and what cannot, but it does not disclose whether the update is partial or full replacement, whether it requires specific permissions, whether it is idempotent, or what happens to unspecified fields. For a mutation tool with 14 parameters, this is a significant gap.

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

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

The description is a single sentence plus a clear exclusion sentence. It is concise and front-loads the main action. The exclusion is valuable and placed at the end. No wasted words, though it could be slightly more structured by grouping parameters.

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

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

Given 14 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the required company_id, the role of ledger_id, the format of vehicle_numbers, or the meaning of is_non_occupied. It also does not state what the tool returns or whether it is a partial update. An agent would need to guess at several parameter semantics.

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

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

Schema description coverage is 0%, so the description must compensate. The description names several fields (contact, address, parking slots, non-occupied status, vehicle numbers) but does not map them to the actual parameter names (e.g., 'contact' vs 'contact', 'parking slots' vs 'two_wheeler_parking_count' and 'four_wheeler_parking_count'). It also omits several parameters like city, state, flat_no, pincode, ledger_id, ledger_name, email, and company_id. The description adds some meaning but leaves many parameters unexplained.

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

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

The description states a clear verb ('Update') and resource ('ledger contact') and enumerates the specific fields that can be updated (contact, address, parking slots, non-occupied status, vehicle numbers). It also explicitly lists what cannot be updated (GSTIN/PAN/Legal Name), which helps distinguish it from a generic update tool. However, it does not explicitly differentiate it from sibling tools like create_receipt or create_payment, though those are clearly different operations.

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

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

The description implies usage: use this tool when you need to update contact or address details for a ledger. It does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. The explicit 'CANNOT update GSTIN/PAN/Legal Name' provides a partial exclusion, but there is no guidance on when to prefer a sibling tool or what prerequisites exist (e.g., ledger must exist).

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