PNPC-MCP-Tally-Prime

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

Annotations already indicate destructive and non-idempotent behavior, but the description adds valuable detail: the exact XML is sent unchanged, and a previewId can only be confirmed once, with reuse failing rather than silently reposting. This meaningfully exceeds annotation-only information and matches the destructive hint.

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

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

Three focused sentences with no filler. The core purpose and exclusive write behavior are front-loaded, followed by the parameter source and the one-time-use constraint.

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 confirmation tool with annotations covering safety, the description covers the workflow, source of the ID, exclusivity of the write, and failure behavior on reuse. Nothing critical is missing for an agent to call 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?

The schema already documents previewId as returned by preview_write, so the baseline is 3. The description adds context that this ID ties to a previously-built preview and that the exact XML is transmitted unchanged, reinforcing the parameter's significance beyond a simple string field.

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

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

States a specific action (post a preview), a resource (Tally), and the exact workflow stage (after preview_write). It explicitly distinguishes itself as the only tool that actually writes for previewed batches, so an agent can clearly separate it from preview_write and the many create/update siblings.

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

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

Gives an explicit when-to-use rule: after preview_write, using the returned previewId. It also names preview_write as the required precursor and notes that reuse of confirmed/expired IDs fails, marking the boundary of the operation.

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

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

Annotations (readOnlyHint=false, idempotentHint=false) already signal this is a mutating, non-idempotent write, and the description's 'Create' is consistent with them. The description adds the prerequisite/ordering context between category and cost centre, which is useful. However, it does not disclose duplicate-name behavior, failure modes, or the need for a prior set_company call, so the added behavioral context is modest.

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 primary action is front-loaded, and each additional element — the parenthetical example and the prerequisite note — earns its place by disambiguating the concept and guiding when to call.

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?

Adequate for a simple 3-parameter create with no nested objects and a fully documented schema. However, there is no output schema and the description says nothing about return values, duplicate-name behavior, or the write-confirmation workflow hinted at by the preview_write and confirm_write siblings — clear gaps an agent must guess at.

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

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

Schema description coverage is 100% — all three parameters (name, allocateToRevenue, allocateToNonRevenue) are already documented with types and defaults in the input schema. The description adds no parameter-specific meaning 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 ('Create a new Cost Category in TallyPrime') and clarifies the domain concept with concrete examples ('grouping of cost centres, e.g. Branch, Project'). This actively distinguishes it from the sibling create_cost_centre by defining the containment relationship between category and centre.

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

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

Provides a clear usage context: 'Required before creating a cost centre under a category that doesn't exist yet.' This effectively tells an agent when this tool is the right choice, implying the alternative (proceeding with create_cost_centre) when the category already exists. It doesn't name alternatives explicitly or state exclusions, so it stops short of a 5.

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

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

Annotations already signal a non-read-only, non-idempotent, non-destructive operation. The description adds useful domain context (cost tracking use case), but does not disclose duplicate-name handling, parent validation, or other creation-time behavior beyond 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?

A single sentence that states the action, gives practical examples, and points to the relevant field on another tool. 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 simple 3-parameter creation tool, the description plus full schema coverage and annotations are mostly sufficient. It could mention duplicate behavior or result shape, but an agent can safely select and invoke it based on the provided context.

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 name, parent, and category, including the default for category. The description adds only entity-level context and a cross-reference to create_voucher; it does not meaningfully expand parameter semantics beyond the schema.

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

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

Description uses a specific verb and resource ('Create a new Cost Centre in TallyPrime') and gives concrete examples (department, branch, project). However, it does not explicitly distinguish this from the sibling create_cost_category, though the cross-reference to create_voucher's costCentre fields helps.

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: when you need a cost centre to tag voucher entries for cost tracking, and it points to create_voucher for related fields. It does not state when not to use it or how it differs from the closely related create_cost_category.

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 annotations all false (no read-only, no idempotent, no destructive flags), the description carries the burden. It discloses that the tool reverses stock and revenue, mentions the dual-role deletion caveats, and provides a live confirmation of the stock quantity increase. This goes beyond the schema and gives the agent a realistic expectation of side effects, though it does not discuss reversibility or error behavior in detail.

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

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

The description is a single, dense paragraph that front-loads the purpose and key distinctions. It is efficient but packs many details (sign pattern, live confirmation, caveats) into one block without bullet points or headings. It remains readable and not overly long, though a structured format could slightly improve scannability.

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 16 parameters and no output schema, the description provides essential context: it explains the accounting semantics, references shared caveats, and gives a concrete validation example. It does not describe the response format or error handling, but the reference to create_sales_invoice for caveats helps fill gaps. The agent would need to consult that sibling for full behavioral detail, so it is not fully self-contained.

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

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

Schema description coverage is 100% and the schema descriptions are detailed (e.g., billType default, godown auto-fill condition, voucherNumber guidance). The tool description adds no new per-parameter meaning beyond referring to the sales invoice's caveats, so it does not need to compensate. Baseline 3 is appropriate because the schema already documents all parameters thoroughly.

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

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

The description states a specific action (create a Credit Note) with a clear resource (item-invoice in TallyPrime) and explicitly differentiates it from create_sales_invoice by the flipped debit/credit convention. It also clarifies it is a Sales return that reverses stock and revenue, making its purpose unambiguous among the many create_* siblings.

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

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

The description gives clear usage context: it is for sales returns, references create_sales_invoice for shared caveats, and notes the difference in sign pattern vs sales invoice. However, it does not explicitly state when NOT to use this tool or name alternative return tools (e.g., create_rejections_in) beyond the sales invoice reference, leaving some inference to the agent.

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

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

Annotations are all false, and the description adds meaningful behavior beyond them: 'reversing stock and expense,' a live empirical confirmation ('returning 3 units correctly decreased the item's book quantity by exactly 3'), and caveat flags ('godown and dual-role deletion caveats'). The dual-role deletion caveat is only referenced, not explained, which slightly weakens the disclosure, but the description otherwise enriches the bare annotation set.

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 sentences with the core purpose front-loaded; each sentence earns its place (what it does, structural relation to a sibling, live validation, caveat pointers). The empirical-validation sentence is slightly tangential but serves an assurance purpose, so 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 17-parameter mutation tool with zeroed annotations and no output schema, the description delivers the essential semantics plus empirical validation, and the schema itself carries exhaustive parameter context. The residual gaps are that the 'dual-role deletion' caveat is punted to another tool's documentation rather than self-contained, and there is no statement about the success/response shape beyond the schema's voucherNumber failure note.

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

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

Schema description coverage is 100%, and the schema's parameter descriptions are exceptionally rich (billType default contrast, buyerTrn vs supplierTrn asymmetry, voucherNumber auto-number failure workaround), so the baseline of 3 applies. The description's 'same shape as create_purchase_invoice' note adds a useful comparative lens but no parameter-specific meaning 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 and resource ('Create an item-invoice Debit Note in TallyPrime') and goes further to define what a Debit Note is in this domain: 'a Purchase return, reversing stock and expense for returned items.' It also distinguishes itself from create_purchase_invoice ('debit/credit convention flipped... structurally a reverse Purchase entry'), which sets it apart from its closest sibling.

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 usage context by defining the tool as a purchase-return document and comparing its shape to create_purchase_invoice, including a shared-caveats pointer. However, it never explicitly states when NOT to use it or how to choose between it and create_credit_note, its mirror alternative — the agent must infer the selection rule from the accounting definition.

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

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

Annotations are all false, so the description carries the full burden of behavioral disclosure, and it delivers excellently. It reveals two confirmed live gotchas: the voucher type must be active or the API falsely reports CREATED:1, and auto-numbering can silently fail with a blank EXCEPTIONS:1. It also explains the workaround (pass voucherNumber explicitly), and that get_ledger_vouchers deliberately excludes inventory-classified vouchers. This is high-value behavioral information far beyond the annotations.

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

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

The description is long but front-loaded: purpose first, sibling distinctions second, then critical warnings. Each sentence carries evidence-backed context, though there is minor redundancy — the voucherNumber guidance appears both in the tool description and in the schema's voucherNumber property. The structure is logical and the density is justified for a tool with multiple live-confirmed failure modes.

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

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

For a 12-parameter creation tool with no output schema and all-false annotations, this description is unusually complete. It covers prerequisites (voucher type active), failure modes (auto-numbering), exclusions (get_ledger_vouchers), and workarounds. The only gap is that it doesn't fully describe the success response shape beyond mentioning CREATED:1 and EXCEPTIONS:1 status markers. That minor omission keeps 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?

With 100% schema description coverage, the baseline is 3. The tool description adds meaningful context beyond the schema: it explains the item-line shape shared with create_sales_invoice (including godown auto-fill behavior), and details the voucherNumber parameter's role in recovering from silent auto-numbering failure. It also notes buyer details fields map to the same block as Sales/Credit Note. These enrich the schema without repeating 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 opens with a precise definition: 'Create a Delivery Note in TallyPrime — an item-line inventory voucher recording goods dispatched to a customer before or without a full Sales invoice.' It names the verb, resource, and the exact scenario, then distinguishes it from create_sales_invoice and create_rejections_out. An agent can determine exactly what this tool does and how it differs from siblings.

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

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

It explicitly states when to use this tool: for dispatching goods before/without a full sales invoice, with ISINVOICE set to No and no VAT/tax line. It also names alternatives: 'Distinct from create_rejections_out, which has no party/ledger amount at all,' and warns that get_ledger_vouchers will never show this voucher by design. This is clear decision 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?

Beyond annotations, the description discloses a live-confirmed behavioral gotcha: pass the parent's plain name, not a dotted path, with a concrete invalid/valid example. It also reveals the downstream failure mode if creation is skipped, giving the agent operational knowledge that the schema and annotations do not provide.

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

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

Three sentences, each earning its place: what the tool does, when it is needed, and the critical path-format rule. The core purpose is front-loaded and no content 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 two-parameter create tool with no output schema and no nested objects, the description covers purpose, prerequisite timing, failure symptoms, and the parameter format pitfall. Nothing essential for selecting and correctly invoking the tool 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?

Although schema coverage is 100%, the description adds critical meaning to the 'parent' parameter by explaining plain-name versus dotted-path usage and giving a concrete example: 'MAIN LOCATION' as parent + 'DUBAI' as name. This substantially reduces the risk of misformatted invocations.

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 'Create a new Godown/Location in TallyPrime', naming a specific verb and resource, and clarifies optional nesting. This clearly distinguishes it from sibling create_* tools like create_ledger, create_group, and create_stock_item, as well as the get_* read tools.

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

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

It provides a clear trigger: use before referencing a godown that doesn't yet exist on an invoice/voucher line, otherwise the call fails with 'Godown does not exist!'. It does not explicitly name alternative tools or state when-not-to-use conditions, so it falls just short of a 5.

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

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

Annotations establish that this is not read-only and is not idempotent, so the description correctly conveys a mutating operation. It adds the dual create/rename behavior, which is useful, but it does not disclose consequences such as duplicate-name behavior, whether renaming affects related ledgers, or what happens if the parent group is missing.

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

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

The description is a single concise sentence that front-loads the core action and immediately clarifies the two operational modes. Every phrase earns its place, with no filler or repetition of already-structured schema details.

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

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

For a three-parameter create/update tool with no output schema, the description covers the essential decision point (oldName) and the meaning of parent. It is slightly thin on failure modes and side effects, but the schema plus this description are sufficient for an agent to invoke it correctly in most cases.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining that 'parent' establishes nesting and that oldName switches the operation to rename/reparent, which directly clarifies parameter usage in context.

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: creating a new account group nested under a parent, with an explicit alternative mode to rename/reparent an existing group via oldName. It names the specific resource type ('account group in TallyPrime') and distinguishes itself from read-oriented siblings like get_groups and other create_* tools.

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

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

The description gives a clear behavioral condition: pass oldName to rename/reparent rather than create a new group. It implies the default use case (new group) but does not explicitly mention alternatives like list groups first with get_groups or use create_stock_group for stock groups, so it is clear but not exhaustive.

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

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

Annotations are all neutral false values and carry no safety profile, so the description carries the burden. It discloses the internal nesting structure (VOUCHERCOMPONENTLIST.LIST inside BATCHALLOCATIONS.LIST inside ALLINVENTORYENTRIES.LIST with PARENTITEM back-references), a live confirmation that creation produces no VAT/tax lines and a single balancing party ledger entry, and the voucher-type-active prerequisite. It does not address idempotency/duplicate behavior or the response format, but for a create tool the disclosed traits are 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?

The purpose is front-loaded, but the middle section spends several clauses on raw XML tag names (VOUCHERCOMPONENTLIST.LIST, BATCHALLOCATIONS.LIST, PARENTITEM) that an agent never constructs — the input schema already encodes that nesting via items[].components. Key operational facts (orderNumber and dueDate required, voucher-type-active prerequisite) appear late, trailing the reverse-engineering detail. Informative but noticeably 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 high-complexity creation tool with no output schema and uninformative annotations, the description covers the business context, the nested data model, a live creation confirmation, the prerequisite, and the sibling distinction — far more than typical create tools. The main gap is that it never states what a successful call returns or how errors surface; the blank-EXCEPTIONS/voucherNumber workaround lives only in the schema. Minor omission against an otherwise thorough definition.

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

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

Schema description coverage is 100% and the schema already documents every parameter, including the items/components nesting, godown auto-fill behavior, batchName defaults, and the voucherNumber EXCEPTIONS:1 workaround. The description adds business framing (finished item vs customer-supplied components) and the rationale for required dueDate/orderNumber, but much of that is echoed in the schema, so incremental value is modest — matching the baseline for high schema coverage.

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

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

The opening sentence names a specific verb (Create), a specific resource (Job Work In Order), and the governing business context (this company is the job worker processing customer-supplied raw materials into finished goods). It also explicitly names the sibling it is not (create_job_work_out_order), so an agent can tell them apart without opening either schema.

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

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

States the defining directional condition for selection: use when this company is the job worker receiving materials from a customer, and names create_job_work_out_order as the alternative for the opposite direction. It also cites the voucher-type-active prerequisite and the create_sales_order precedent for the required orderNumber/dueDate fields, leaving no ambiguity about when the tool applies.

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

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

Annotations are all false, so the description carries the behavioral burden and it delivers: 'Confirmed live: creates cleanly with no exceptions' is genuine operational insight, and the voucher-type-active prerequisite warns of a realistic failure mode. The voucherNumber parameter description also discloses the known auto-numbering outage and the get_vouchers retry strategy. No contradiction with annotations — readOnlyHint=false is consistent with a create operation. Minor gap: no statement about what the response returns on success beyond 'no exceptions.'

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?

Dense but purposeful — every sentence earns its place (scenario, mirror relationship, direction convention, live confirmation, prerequisites, required fields). Slightly redundant in explaining the accounting direction twice ('flipped' and 'inward expected receipt rather than outward delivery'), but the front-loading of core purpose before structural details is well ordered.

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 complex nested creation tool with no output schema and minimal annotations, the description covers every decision-relevant aspect: when to use it, how it relates to siblings, the nested item/component structure, prerequisites, required fields, and a confirmed-live status. Even the schema's nested-object complexity (which the context signal under-reports) is explicitly explained in the description, so nothing an agent needs to invoke it 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?

Schema coverage is 100%, so the baseline is 3 and the schema already documents every parameter well. The description adds value above the schema by framing the conceptual mapping: each item line is the finished item expected back, while the nested components list is the raw materials to send out. This clarifies the semantics of the whole items array in business terms that the flat schema properties alone don't convey.

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 Job Work Out Order in TallyPrime') with a precise business scenario: this company is the principal sending raw materials to a job worker and expecting finished items back. Explicitly differentiates from its near-twin sibling create_job_work_in_order by calling it the mirror image with the accounting direction flipped, so an agent can distinguish them without opening either schema.

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

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

Explicit when-to-use guidance: 'used when this company is the principal, sending raw materials out to a job worker (subcontractor) and expecting a finished item back.' Names the alternative (create_job_work_in_order) and the direction relationship via the existing create_sales_order vs create_purchase_order sign convention, which lets an agent generalize from sibling pairs it may already understand. Also states the voucher-type-active prerequisite.

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

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

Annotations already communicate that this is a write operation, is not idempotent, and is not flagged destructive. The description adds the useful update/rename behavior, but does not disclose what happens in edge cases such as an oldName that does not exist or whether unspecified fields are overwritten on update. With annotations present, this is adequate but not 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?

The description is a single, front-loaded sentence with no filler. It states the primary action first, then the secondary mode, and every word earns its place.

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

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

Given the rich 100%-covered input schema and the explicit annotations, the description is mostly complete for selection and invocation. The main gap is the lack of any mention of return value or success/failure indication, especially since no output schema is provided. Still, the core behavior and mode selection are well covered.

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

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

Schema description coverage is 100%, with detailed explanations for all 19 parameters including examples and caveats. The tool description itself adds little beyond pointing to oldName, so the schema carries the parameter-semantics burden and the baseline of 3 applies.

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

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

The description uses a specific verb ('Create') and a concrete resource ('ledger (account) in TallyPrime'), and immediately clarifies the dual create/update capability with 'rename/update an existing one by passing oldName'. This clearly differentiates it from sibling tools like create_group and get_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?

The description gives clear usage context: create a new ledger, or update/rename an existing one by supplying oldName. It does not explicitly name alternative tools or state when not to use it, but the primary usage scenario is unambiguous.

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

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

The description goes well beyond the annotations: it reveals that this is a memorandum posting without real accounting impact, that it uses Tally's 'Multi Consumption Voucher View' shape, that the template is extrapolated and unverified, and that users should verify carefully. It also documents a known failure mode (LINEERROR 'Voucher date is missing') and the exact remedy (set_period + retry). This is rich behavioral disclosure beyond the readOnly/destructive hints.

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?

Every sentence earns its place: the first defines the tool, the next gives the job-work context and caveat, then the godown warning, then a concrete troubleshooting path. It is long but information-dense, front-loaded with the core purpose and structured so the warnings and error handling are easy to locate.

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

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

No output schema exists, and the description doesn't describe the success response, but it does cover the most important operational context: prerequisites (party ledger, items, date), conditional requirements (godown), and failure recovery (set_period, voucherNumber fallback). For a creation tool, error modes are as important as success output, and those are thoroughly covered; only a brief note on expected success behavior is absent.

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

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

Schema coverage is 100%, so each parameter already has a description. The tool description adds value on top by advising to 'pass godown on every item' when godown/batch tracking is enabled, and by explaining the voucherNumber auto-numbering caveat and the EXCEPTIONS:1 retry strategy. This supplements the schema rather than repeating 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 opens with a specific verb and resource: 'Create a Material In voucher in TallyPrime' and immediately defines its exact purpose: recording stock received back from a job worker or party holding material, with the key distinction that it is job-work memorandum tracking, not a purchase. This differentiates it clearly from purchase vouchers and other sibling tools like create_material_out or create_rejections_in.

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 strong contextual guidance: it explains when this voucher type is appropriate (job-work returns, non-purchase tracking) and explicitly flags when to be cautious (godown/batch companies, active-period issues). It does not name specific alternative tools for explicit when-not-to-use, but the 'not a purchase' statement and the job-worker framing provide enough direction for an agent to select it over siblings.

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

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

The description discloses important behavioral traits beyond the annotation hints: this is job-work memorandum tracking with no real accounting posting, stock is sent out, and it is not a sale. It also documents a known live error ('Voucher date is missing') and the exact remediation using set_period. The only weakness is the cryptic, undefined 'EXTRAPOLATED caveat' reference, which reduces some transparency.

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

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

The description is compact and front-loaded: purpose first, relationship to sibling second, and error-handling guidance last. Every major point is covered without filler. It loses a point because 'Same EXTRAPOLATED caveat' is opaque and would mean nothing to an agent without access to the sibling tool's full documentation.

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

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

The description is strong on purpose, side effects, and known failure recovery, which is a lot of context for a create-type tool with no output schema. However, it is not fully standalone: the 'EXTRAPOLATED caveat' is never explained, and the description does not mention what successful execution returns or confirms. These are meaningful gaps for an agent deciding whether the call succeeded.

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 has 100% description coverage for all parameters, including date format, partyLedger, items, and voucherNumber behavior. The tool description reinforces the godown requirement and the date field error, but it does not add new field-level semantics beyond what the schema 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 opens with a specific verb and resource: 'Create a Material Out voucher'. It then defines the exact business purpose — recording stock sent to a job worker for processing — and explicitly distinguishes this from a sale ('not a sale') and from its inbound counterpart ('Mirror of create_material_in'). An agent can confidently tell this tool apart from creation_voucher, create_material_in, and sales-related tools.

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

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

It gives clear context for when to use the tool: when stock is sent out to a job worker for processing, as a memorandum rather than a real accounting transaction. It also names create_material_in as a mirror and notes a recovery path via set_period. However, it does not explicitly enumerate all the alternatives it should not be used for (e.g., sales invoice, delivery note, rejection out), so the guidance is strong but not exhaustive.

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 readOnlyHint=false, the description carries the burden of disclosing mutation behavior and exceeds it: it discloses a prior failure mode ('an earlier version of this tool was found to corrupt the closing balance to a nonsensical negative number'), the fix verification ('counting 95 of an item that had 100 correctly closed the item at 95'), a technical XML detail (DIFFACTUALQTY=Yes at voucher level), and a deliberate non-behavior (no ledger write-off). No contradiction with annotations — readOnlyHint=false aligns with the stated balance mutation.

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

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

The purpose is front-loaded in sentence one and the create_voucher boundary is a clean closing sentence. However, the middle sentence is a ~55-word run-on mixing low-signal implementation minutiae (DIFFACTUALQTY, per-line flag, XML template) with the verification story, which could be split and trimmed. At roughly 95 words, it is informative but denser than necessary for an agent deciding whether to invoke.

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

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

For a write tool with readOnlyHint=false and no output schema, the description covers the essential operational facts: what it mutates, the verified behavior, the scope boundary (no monetary posting), and the known failure path is covered in the schema's voucherNumber guidance. The only gaps are the lack of explicit return-value expectations and the missing update_physical_stock contrast — minor given the rich schema carrying the godown and retry edge cases.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already documents date format (DD-MM-YYYY), godown auto-fill conditional behavior and failure mode ('the call fails naming the available godowns'), batchName default, and voucherNumber retry logic. The description adds tool-level context but no per-parameter meaning beyond what the schema provides, so it neither needs to compensate nor does it elevate.

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 ('Create') and resource ('Physical Stock voucher in TallyPrime') and defines the core behavior: 'records a physical count and updates the stock item's book quantity to match it (that's the point of the voucher)'. It explicitly distinguishes itself from create_voucher by stating what it does NOT do ('does not post any monetary/ledger write-off'), making sibling differentiation concrete.

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

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

The description gives an explicit alternative and condition: 'do that separately with create_voucher if needed' for the shortage/excess write-off. The schema adds a concrete retry path via get_vouchers when creation fails with 'EXCEPTIONS:1' and voucherNumber guidance. However, it never contrasts with the natural sibling update_physical_stock, so when to create vs. update is left to name inference 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?

The annotations provide little behavioral signal because all hints are false, so the description carries the burden. It does this exceptionally well by disclosing a confirmed live side effect: using the same party ledger or stock item in both Sales and Purchase item-invoices can make vouchers undeletable via the API. It also gives a concrete remediation path and clarifies the issue is not permanent.

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 purpose, then moves to a clearly marked warning section. Every sentence earns its place, especially the warning, which provides confirmed live testing context and a workaround. There is no filler or repetition.

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

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

Given the complex 17-parameter surface, the description plus the exhaustive schema cover the tool well and highlight the most critical behavioral caveat. However, with no output schema, the description does not state what a successful call returns or how the agent should confirm the voucher was created, which leaves a small but real completeness 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 each parameter already has a rich, field-level explanation. The tool description adds useful high-level context about item lines and ledger posting, but it does not add meaning to individual parameters beyond the schema. This matches 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?

The description clearly states the action and resource: 'Create an item-invoice Purchase voucher in TallyPrime'. It also distinguishes itself from the closely related sibling by labeling it the buying-side mirror of create_sales_invoice, and it adds concrete structural detail about item lines, Purchase ledgers, and a VAT/tax line.

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

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

The description provides clear context: this is the tool for purchase-side item-invoices, positioned as the counterpart to create_sales_invoice. However, it does not explicitly state when not to use it or name alternatives like generic create_voucher for other voucher types, so it stops short of full exclusion guidance.

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

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

All four annotations are false, so the description carries the behavioral burden — and it delivers: it discloses the Order-class voucher classification, the voucher-type-active prerequisite (confirmed live), the live failure mode for missing dueDate, and Auto Retain numbering behavior. The main gap is that some details are cross-referenced ('same reasoning as create_sales_order') rather than self-contained, so the agent must look to sibling definitions for full specifics.

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 sentences, roughly 115 words, with zero filler: definition, sibling differentiation, follow-up workflow, then prerequisites and required fields. It is front-loaded with the most important positioning. The final sentence is slightly dense with stacked cross-references, but 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 complex write tool (6 top-level params, 9 item sub-fields) with no output schema and all-false annotations, the description covers the essentials: what the voucher is, where it sits in the workflow, prerequisites, and required fields. What remains unspecified is the success envelope (there is no output schema) and the exact meaning of the referenced Auto Retain numbering behavior, though the schema's voucherNumber note partially compensates.

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

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

Schema coverage is 100%, with richly detailed parameter descriptions (godown auto-fill logic, batchName default, the EXCEPTIONS:1 recovery hint on voucherNumber, and dueDate's exact Tally error message). The description re-emphasizes that orderNumber and dueDate are REQUIRED and explains their provenance, which is useful reinforcement but not additive semantic content beyond the schema. 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 opening sentence defines the tool precisely: 'Create a Purchase Order in TallyPrime — a future commitment to buy, before any goods move or invoicing happens.' It names the verb, resource, and the business moment in the purchase lifecycle, and immediately distinguishes it from siblings by calling out that create_purchase_invoice/create_receipt_note are different voucher types.

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

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

The description explicitly routes the agent: same item-line shape as create_purchase_invoice/create_receipt_note but with VCHTYPE 'Purchase Order', plus a sequenced follow-up instruction — 'Follow up with create_receipt_note (goods in) and/or create_purchase_invoice (billing)' once goods arrive. It even cross-references the voucher-type-active prerequisite from create_delivery_note, giving the agent concrete when-to-use and operational context.

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

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

Annotations are all false and carry almost no information, so the description bears the full burden — and delivers. It discloses the voucher-type-activation prerequisite, the visibility quirk ('won't show up in get_vouchers/delete_voucher until it is' active; get_ledger_vouchers will 'never show it, by design'), and two confirmed error-recovery paths (LINEERROR 'Voucher date is missing' → call set_period and retry; blank EXCEPTIONS:1 → set voucherNumber from get_vouchers). This is precisely the behavioral color an agent cannot infer from annotations or 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?

Roughly 170 words, but no sentence is filler: purpose is front-loaded, sibling differentiation takes one clause, and the remainder is operationally necessary caveat (activation prerequisite, ledger-visibility design, date-period recovery, numbering recovery). Slightly dense and could be tightened, but the length is justified for a complex write tool with documented gotchas.

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 13-parameter write tool with no output schema and uninformative annotations, the description covers every realistic failure mode and prerequisite: voucher-type activation, date-period errors, auto-numbering failures, and the get_ledger_vouchers exclusion. The only omission is the success-return shape, which is a minor gap given no output schema and sibling consistency.

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

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

Schema coverage is 100%, so the baseline is 3: every parameter already has a substantive schema description (godown's auto-fill vs required behavior, batchName's default, voucherNumber's numbering caveat). The tool description adds voucher-level framing (item-line shape, ISINVOICE=No, no VAT/tax line) but not per-parameter detail, which is appropriate — it does not exceed the schema-driven 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+resource ('Create a Receipt Note in TallyPrime') and the operational semantics: an 'item-line inventory voucher recording goods received from a supplier before or without a full Purchase invoice'. Explicitly differentiates from siblings — 'Same item-line shape as create_purchase_invoice... but ISINVOICE is set to No and there's no VAT/tax line' — and positions it as the buying-side mirror of create_delivery_note. An agent can distinguish this from every other create_* sibling 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?

Gives clear context for when to use it: goods received before or without a full Purchase invoice, e.g. against a Purchase Order. The comparison to create_purchase_invoice (ISINVOICE=No, no VAT line) and the create_delivery_note mirror effectively establish selection criteria, though it stops short of explicitly listing when NOT to use it in favor of other voucher types.

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

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

The description goes well beyond the minimal annotation set by disclosing operational caveats: godown behavior, extrapolated XML shape, the LINEERROR date-period failure and its set_period workaround, and voucher-numbering edge cases. It also honestly flags uncertainty about the exact voucher format.

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 longer than average, but every sentence carries operational value: purpose, scope, caveats, and troubleshooting. It is front-loaded with the core definition and then adds necessary behavioral detail.

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

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

For a complex write tool with no output schema and sparse annotations, the description covers the key risks an agent needs to know: required godowns, active-period date failures, auto-numbering pitfalls, and the need to verify results. It is sufficiently complete for reliable invocation and error recovery.

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

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

Schema coverage is 100%, so the schema already documents the parameters well. The description adds useful context around godown auto-filling and voucherNumber retry behavior, but most parameter semantics are already present in the input 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 the specific action: creating a Rejections In voucher in TallyPrime. It explains the business scenario (goods rejected and returned by a customer or job worker) and distinguishes it from sales/purchase vouchers by noting it is inventory-movement-only with no party ledger.

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

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

The description gives clear context on when to use this tool: when goods are being returned to the company as rejected. It does not explicitly name alternatives like create_rejections_out, but the scenario is specific enough for an agent to select it appropriately.

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

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

The description discloses several behavioral aspects: it creates a voucher (write operation), warns about the 'EXTRAPOLATED caveat' and godown requirement, and details a specific failure mode for voucherNumber with a workaround. Given the minimal annotations, this carries the burden well, though it doesn't cover all possible side effects.

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

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

The description is concise at ~3 sentences, starts with the core purpose, and efficiently packs the mirror reference, caveat, and error handling without unnecessary fluff. It's well-structured and 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 the complexity (4 top-level params, nested items), the description covers the purpose, typical use cases, and two key error scenarios (date period and voucher numbering). It doesn't mention preconditions like requiring a set company, but that's implied given the TallyPrime context and sibling 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 input schema has 100% description coverage, so the baseline is 3. The tool description itself adds no extra parameter semantics beyond what's already in the schema; all parameter details are provided in the schema descriptions.

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

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

The description clearly states 'Create a Rejections Out voucher', specifies it records goods being rejected and returned outward, and gives concrete examples (supplier, job worker). The mention of being a 'Mirror of create_rejections_in' helps distinguish it from the sibling 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?

It explains when to use it (rejecting goods going out) and includes specific error handling instructions (calling set_period on date errors). However, it doesn't explicitly contrast with create_rejections_in or other create tools beyond the mirror reference, so it's clear but not fully explicit.

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

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

Annotations only say readOnlyHint=false and destructiveHint=false, which is thin; the description carries the full burden and delivers exceptional value. It discloses a confirmed-live behavioral hazard — vouchers becoming undeletable via API when shared party/stock items are used across Sales and Purchase invoices — plus the exact recovery path (Company Data → Rewrite) and the confirmation that it is not a permanent lock.

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, and the core purpose is front-loaded before the sibling distinction and the warning. The warning is long but every word earns its place — it conveys a live-confirmed failure mode and its workaround, which is exactly the kind of content that must not be trimmed.

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 16-parameter mutation tool with no output schema, the description covers core function, sibling differentiation, and the critical lock hazard; the schema covers every parameter exhaustively. The only gap is that no explicit success-return shape is stated, though the schema's CREATED:0/EXCEPTIONS:1 hints let an agent infer the Tally gateway response pattern.

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 16 parameters in rich detail (including failure modes like the godown silent fail), putting this at the baseline 3. The tool description adds mild structural meaning — per-line salesLedger vs. one VAT line on the total — but does not meaningfully compensate 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 and resource ('Create an item-invoice Sales voucher in TallyPrime') with concrete detail about what it produces: stock item lines with quantity/rate, each posted to its own Sales ledger, plus an optional VAT/tax line. It explicitly names the confusable sibling and its limitation ('Distinct from create_voucher, which only supports plain ledger-to-ledger entries with no stock items'), so an agent can tell it apart without opening 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 an explicit when/hen-not: use this for item-invoices with stock item lines, and names create_voucher as the alternative for plain ledger-to-ledger entries. The live warning about the same party/stock item appearing in BOTH a Sales and Purchase item-invoice also implicitly guides when NOT to combine this tool with create_purchase_invoice on the same masters.

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?

All four annotations are neutral/false, so the description carries the full behavioral burden and over-delivers: Tally silently reassigns voucher numbers regardless of an explicit voucherNumber (Auto Retain numbering), and it rejects Order-class vouchers with exact missing-field messages ('Order No. is missing in Item Allocations', 'Due Date of Order is missing in Item Allocations'). It also reveals the reverse-engineered XML mapping — voucher-level REFERENCE tag and item-nested BATCHALLOCATIONS.LIST — which is exactly the non-obvious behavior an agent cannot infer from schema or annotations. No contradiction with the annotations (write operation matches readOnlyHint=false).

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 ~230-word description is dense but nearly every block earns its place — prerequisites, fatal error messages, field-to-XML mapping, and post-create verification are all load-bearing for correct invocation. It could be tightened (the 'confirmed live' caveat appears twice and the required-field error text is partly restated in the schema), and the single-paragraph wall of text would benefit from light structuring, but there is no fluff.

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

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

For a write tool with high quirk quotient and no output schema, nothing essential is missing: it covers the prerequisite, exact failure messages, the XML nesting that dictates how items must be shaped, and the post-condition instruction to verify the assigned voucher number via get_vouchers. The only nominal gap, the success response format, is practically compensated by the explicit follow-up verification 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?

Schema coverage is 100%, so the baseline is 3, but the description adds genuine meaning beyond the schema: orderNumber is 'the order reference shown as Order no. in Tally's UI' backed by the REFERENCE tag and independent of voucherNumber (real example: voucherNumber '1' vs Order no. '12345'), and it clarifies that per-item Order No./dueDate live inside BATCHALLOCATIONS.LIST rather than as direct ALLINVENTORYENTRIES fields. Not every parameter gets enrichment (date, partyLedger, narration rest on the schema), which keeps this at 4.

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

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

Opens with a specific verb and resource — 'Create a Sales Order in TallyPrime — a future commitment to sell' — which immediately scopes the operation as pre-dispatch and pre-invoicing. It then distinguishes the tool from create_sales_invoice and create_delivery_note by voucher class ('Order-class voucher, structurally different from Delivery Note's inventory-class'), so an agent can pick it correctly among dozens of create_* siblings without opening schemas.

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

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

The description gives explicit workflow sequencing: create the order first, then 'follow up with create_delivery_note (dispatch) and/or create_sales_invoice (billing) ... once goods actually move' — which both states when this tool applies and implicitly when the siblings replace it. It also names the voucher-type-active prerequisite shared with create_delivery_note and a concrete retry rule for voucherNumber (blank EXCEPTIONS:1 → check get_vouchers and pass the next number).

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 annotations only carrying generic flags (write, not idempotent, not destructive), the description takes on the behavioral burden and delivers substantive details: Tally classifies Sales Quotation as an Order-class voucher ('PARENT Sales Order'), and Tally 'rejects it the same way' without orderNumber and per-item dueDate. It also discloses the voucher-type-active prerequisite. It stops short of describing success-path behavior, but the disclosed failure modes are the operative risks for this 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 sentences, front-loaded with the core purpose and scoped against the sibling. The middle sentence is dense but packs the substantiated requirements and the confirmed-live rationale. Minor redundancy across 'Same ... same way ... Same' is a small cost for the behavioral precision it buys.

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-parameter create tool with 100% schema coverage and no output schema, the description covers workflow position, prerequisites, and rejection behavior, while the schema fully documents every parameter. Success-return behavior is not described, but with no output schema and the failure mode disclosed, nothing critical is missing for this tool's complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining why orderNumber and per-item dueDate are non-negotiable — grounded in Tally's Order-class voucher classification — rather than merely restating that they are required. The cross-reference to create_sales_order's 'same item-line shape' also lets the agent transfer known parameter semantics from a sibling.

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 ('Create') and resource ('Sales Quotation in TallyPrime') and immediately distinguishes the tool from its closest sibling: 'one step before create_sales_order.' Combined with the follow-up note, an agent can unambiguously separate this tool from create_sales_order, create_sales_invoice, and update_sales_quotation.

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

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

The description explicitly positions the tool in the sales workflow — 'one step before create_sales_order' — and names the exact follow-up action: 'Follow up with create_sales_order once the customer accepts.' It also anchors a prerequisite to a named sibling ('Same voucher-type-active prerequisite as create_delivery_note'), giving concrete when-to-call and when-to-stop guidance.

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

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

Annotations indicate readOnlyHint: false, and the description aligns by stating 'Create a new Stock Group'. It adds context about the relationship to stock items, but does not detail side effects like idempotency or error behavior; annotations already cover the read-only aspect, so the bar is met.

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 concise—three sentences—and well-structured: it states the purpose, distinguishes from a sibling, and gives a prerequisite. No unnecessary information is included.

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

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

The description includes the prerequisite relationship (required before creating a stock item) and clarifies the distinction from account groups. It does not mention the return type or error handling, but given the absence of an output schema, the context is sufficiently complete for an agent to decide when to invoke 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 input schema provides descriptions for both parameters (name and parent), achieving 100% coverage. The tool description does not add extra semantics beyond what the schema already states, so the baseline score of 3 is appropriate.

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

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

The description clearly states the purpose: to create a new Stock Group in TallyPrime. It also distinguishes it from the sibling create_group (account groups) and specifies its role as the category for stock items, making the tool's intent 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 explicitly provides usage conditions: it is required before creating a stock item under a new category, and it contrasts with create_group, giving clear guidance on when to select this tool over alternatives.

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

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

Annotations already indicate this is a mutating, non-idempotent operation, but the description adds no behavioral detail beyond 'create'. It does not disclose what happens on duplicate names, whether existing stock items are replaced, whether Tally-side validation is performed, or what the caller should expect after invocation.

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

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

The description is a single, focused sentence with no filler or redundant elaboration. It is efficient and immediately readable, though minimal in scope.

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

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

For a tool with 9 parameters, no output schema, and many sibling creation tools, the description is too sparse. It omits necessary context like success/error behavior, required existing masters (e.g., group/unit), and the relationship to update_stock_item. The rich schema helps but does not compensate for the missing usage and outcome context.

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 every parameter is already well documented in the input schema. The tool description adds no parameter semantics, but the baseline of 3 applies because the schema carries the full burden and does so effectively.

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

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

The description clearly states the verb ('Create') and the resource ('a new stock item in TallyPrime'), making the tool's basic function unambiguous. It is distinguishable from obvious siblings like update_stock_item and delete_stock_item by the word 'new', though it does not explicitly differentiate itself from other create_* tools 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?

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites such as the stock group or unit already existing, and no note about cases where update_stock_item or create_stock_group would be more appropriate. The usage is only implied by the tool name, which is insufficient given the large sibling set.

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

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

Discloses key behaviors: inventory-only (no ledger entries), auto-fill logic for godowns, auto-numbering pitfalls, and how additional costs are allocated. This transparency is especially valuable given the write 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 detailed but well-organized, with the main paragraph providing an overview and parameter-level details following. No fluff; every sentence carries relevant operational information.

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

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

Covers all relevant operational contexts: creation behavior, multi-godown requirements, auto-numbering pitfalls, and cost allocation. Even without an output schema, it addresses potential error scenarios, making it sufficiently complete for an agent to use 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?

Every parameter is explained beyond the schema, such as 'consumed' vs 'produced' for sources/destinations, defaults for batchName, allocationType for costs, and the distinction between voucherType and voucherNumber. This adds significant meaning beyond the JSON 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 the tool creates a Stock Journal voucher for inventory transfers or manufacturing conversions, explicitly distinguishing it from other inventory voucher types and noting it is inventory-only with no ledger entries.

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

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

Provides explicit guidance on when to use (transfer or manufacturing), how to use the voucherType for manufacturing journals, and detailed notes on auto-numbering and godown handling, including failure scenarios and retry advice.

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 all annotations being false, the description carries the full behavioral burden and does it superbly. It discloses the confirmed live pattern for compound units, the client-side whitespace validation that Tally rejects ('Master name contains invalid characters'), and the fact that decimalPlaces is ignored for compound units. This goes well beyond the annotations.

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

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

The description is a single long paragraph, but every sentence adds necessary information about simple vs. compound units, prerequisites, validation, or failure modes. The key usage requirement is front-loaded. It is dense rather than bloated, but it could benefit from clearer separation of the compound-unit-specific rules.

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-parameter tool with a complex compound-unit semantics, the description is complete: it explains the creation process, dependency chain, validation constraints, and when the tool is required. The absence of an output schema is acceptable for a creation tool, and the description provides everything an agent needs 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?

Even with 100% schema coverage, the description adds critical semantic meaning: it explains how baseUnit/additionalUnit/conversion work together only for compound units, that conversion is required when baseUnit is set, that decimalPlaces defaults to 0, and where whitespace is allowed (symbol vs. display name). This would not be obvious from the schema alone.

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 'Unit of Measure in TallyPrime' and distinguishes simple units (e.g., 'Kg') from compound units (e.g., 'Box of 12 Nos'). This specific verb-resource pair sets it apart from sibling tools like create_stock_item or create_group without needing to inspect schemas.

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

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

The description explicitly says when to use it: 'Required before creating or invoicing a stock item in a unit that doesn't exist yet' and describes the failure mode otherwise. It also gives a sequencing pattern (create simple units first, then compound), but it never explicitly names an alternative tool because none exists for this operation.

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

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

Annotations are all false, so the description carries the burden; it does disclose real behavioral traits: Tally's numbering series can silently restart (with a concrete example), the entries path is pre-validated so double-entry mismatch fails with a clear error before reaching Tally, and buyerTrn/buyerState/buyerCountry behave differently for Sales-class vs Purchase-class vouchers. It stops short of describing the full response shape or other failure modes, which is why it is a 4 rather than 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?

The description is longer than the average tool description, but nearly every clause earns its place: it compresses the 2-leg vs multi-line distinction, the numbering failure workaround, and a cross-tool pointer into roughly three dense sentences. It front-loads the core action and the mode choice before the edge-case voucherNumber caveat. It could be tightened slightly, but it is structured and information-dense rather than 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 22-parameter mutation tool with no output schema, the description does an unusually complete job: it explains when to use entries, when to override numbering, what the double-entry constraint is, how reference relates to bill-wise settlement, and which Sales-class caveats apply to buyerTrn/buyerState/buyerCountry. What is missing is mostly what an agent would learn from the output schema or from trying the tool (e.g. exact response format, whether the call fails synchronously), so the gap is not a description failure.

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

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

Schema description coverage is 100%, so the baseline is 3; the description earns the extra point several ways. It clarifies the mutual exclusivity between entries and debitLedger/creditLedger/amount, explains that entries replaces the simple mode entirely, adds the real-world voucherNumber auto-numbering caveat, distinguishes reference (voucher-level REFERENCE) from per-leg bill references (debitBillName/creditBillName), and gives a working example for reference. These go well beyond restating the property names.

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 phrase 'Create a new voucher ... in TallyPrime', enumerates concrete voucher types (Payment, Receipt, Sales, Purchase, Journal), and immediately differentiates the two supported modes (simple 2-leg vs multi-line entries). This clearly distinguishes it from create_sales_invoice, create_purchase_invoice, update_voucher, and the other sibling create_* tools.

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

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

The description gives explicit when-to-use guidance: use debitLedger/creditLedger/amount for a simple 2-leg voucher, use 'entries' for 3+ lines, and pass voucherNumber only when Tally's auto-numbering misbehaves, with a concrete live example. It also directs the agent to check get_vouchers for the correct next number first, and points to create_purchase_invoice's separate buyerTrn/supplierTrn when the purchase-class caveat applies. This proactively routes to alternatives and even warns against misuse.

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?

Beyond the minimal annotations, the description discloses detailed behavior: the dual create/rename mode, the effect of numberingMethod, the real-world issue of blank voucher numbers if not set, the relationship of useAsManufacturingJournal to Stock Journal, and the escape hatch of extraFields. This is far more transparent than typical tool descriptions.

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

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

The description is long and wraps many caveats into a single flowing paragraph, which can be a bit dense. However, every sentence delivers important operational knowledge, and the main purpose is stated upfront. It is appropriately detailed for the complexity of the operation, though slightly more structured formatting would improve readability.

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 thoroughly covers the operation's semantics, edge cases, and relationships to other tools (e.g., create_stock_journal). It does not mention the return value or error behavior, but for a create/rename tool with no output schema, the focus on input-side behavior is arguably sufficient. A brief note on what it returns would make it 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?

Every parameter has a schema description, and the narrative adds critical nuance for many of them: numberingMethod values and consequences, oldName for renaming, parent needing to exist, extraFields as an unvalidated escape hatch, and useAsManufacturingJournal's actual impact. This exceeds what the raw schema provides.

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

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

The description clearly states the tool's primary action ('Create a new custom Voucher Type') and extends to renaming/reconfiguring existing ones, which is a distinct scope. It differentiates from sibling tools by focusing on the Voucher Type master object and references the need to check get_voucher_types for valid parents.

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

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

The description provides explicit usage guidance: it tells the agent to check existing voucher types via get_voucher_types, explains when to pass oldName to rename vs. create, and warns about numberingMethod pitfalls. It stops short of an explicit 'use this instead of X' comparison with sibling tools, but the context is clear.

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

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

Beyond the annotations (destructiveHint=true), the description discloses two confirmed behavioral caveats: the race condition when deleting a master and its voucher in the same batch, and the permanent 'Cannot be deleted!' scenario that requires a Company Data rewrite in Tally. These are rich, operationally critical details that annotations alone do not capture.

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 and front-loaded with the primary purpose, then followed by a high-value operational warning. There is no filler or unnecessary repetition, and the additional clauses all contribute useful context.

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

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

For a destructive, multi-type deletion tool without an output schema, the description covers the essential use case: general usage, sequencing with vouchers, known race condition, a specific permanent error, and the Tally-side fix. It provides enough operational context to use the tool safely and to understand what can go wrong.

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

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

The input schema describes both parameters in detail, including the collection of XML tag names and the exact names array; schema coverage is 100%. The description restates examples of master types but adds no new information about parameter formats, constraints, or behavior 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 explicitly states the action: 'Delete one or more masters (ledger, group, stock item, voucher type, unit, godown, cost centre, etc.) by name.' It names both the verb and the resource scope, and it distinguishes this generic deletion tool from sibling tools like delete_stock_item and delete_voucher which are type-specific.

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

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

The description provides concrete usage guidance: delete a voucher first and confirm success before deleting the related master, and avoid parallel batch execution to prevent a race. It also explicitly states that a certain permanent deletion failure should be handled with a Tally rewrite, not retry or sequencing. However, it does not explicitly say 'use delete_stock_item instead for stock items' or otherwise contrast with the sibling delete tools.

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

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

Annotations already indicate destructive and idempotent behavior, but the description adds substantial context: failure conditions, race-condition warning, and a specific error with a resolution (Company Data → Rewrite). This goes far beyond annotations, revealing realistic edge cases and 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 concise yet information-dense. It opens with the core action, then lists failure conditions, sequencing advice, and a known workaround—all within four sentences. Every sentence provides actionable value without 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?

Despite having no output schema, the description covers all critical aspects: success/failure conditions, concurrency concerns, and a known permanent failure with a manual fix. Given the tool's destructive nature and potential for confusion, the description is fully complete for an agent to use 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?

The input schema fully documents the single parameter 'name' with its description 'Exact name of the stock item to delete' (100% coverage). The description does not add additional parameter detail, but it does imply the need for exactness by stating deletion behavior. This meets the baseline for high schema coverage.

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

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

Description clearly states the action: 'Delete a stock item from TallyPrime' with a specific verb and resource. It distinguishes itself from sibling tools like delete_voucher and delete_master by explicitly targeting stock items, making its purpose 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?

Provides explicit conditions for use, such as failing when transactions exist, and sequencing advice to delete vouchers first to avoid races. It also mentions a known failure scenario and suggests a manual fix. While it doesn't explicitly name alternative tools for other resource types, the context is sufficient for proper usage.

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

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

The description goes well beyond the annotations by disclosing that deletion removes the voucher 'with no trace,' that it has no undo, and that it refuses when another voucher type shares the same number due to Tally's lookup ignoring voucher type. These are non-obvious behavioral traits that materially affect invocation and expected outcomes.

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

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

The description is three sentences with no filler. It front-loads the core action and irreversibility warning, then explains the matching criteria and a critical collision caveat. Every sentence earns its place and no important context is 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?

Despite no output schema, the description provides everything needed to use the tool correctly: prerequisites (verify existence), matching rules, irreversibility, and the specific failure mode around number collisions. For a destructive operation with Tally quirks, this is exceptionally complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context by explaining that the three parameters form a composite match key, must be unique, and must exactly match an existing voucher—information that helps the agent correctly construct the parameters beyond simple type definitions.

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

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

The description states a specific verb ('permanently delete') and resource ('existing voucher from TallyPrime'), and explicitly distinguishes it from cancelling, which is a different outcome. It clearly separates this tool from read-only sibling tools and other delete tools like delete_master or delete_stock_item.

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

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

The description explicitly tells the agent when to use this tool (when permanent deletion with no trace is intended), and contrasts it with the alternative of cancelling. It also instructs the agent to first confirm the voucher exists using get_ledger_vouchers or get_vouchers, and warns that the tool refuses on number collisions—so the agent knows to resolve the collision beforehand.

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?

Beyond the readOnlyHint and openWorldHint annotations, the description discloses retention behavior (90-day deletion checked once per startup), best-effort company tagging, that all read and write calls are logged, and outcome categories. This is substantial behavior context the annotations do not provide.

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

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

The description is front-loaded with the core purpose, followed immediately by the critical retention caveat and typical use cases. Every sentence adds needed context and none are redundant or ornamental.

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 seven parameters and no output schema, the description still tells an agent what entries contain, how outcome and company are represented, what the retention limits are, and when to use the summary format. No critical call-time decision is left 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?

Schema description coverage is 100%, so the schema already documents every parameter. The description contributes marginal context such as the purpose of writesOnly and best-effort company tagging semantics, but the baseline of 3 is appropriate since the schema carries the main parameter burden.

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: read the connector's append-only audit log. It enumerates the content of entries (timestamp, arguments, outcome, company tag), making the tool's purpose concrete and distinct from all sibling getters and mutation tools.

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

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

The description explicitly says when to use this tool: to review what an agent actually did against the Tally company, before trusting a session's claimed results, or to hand a reviewer a record of writes. It also gives a when-not by warning this is not a full historical record beyond 90 days.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description properly states it returns a balance sheet, which aligns with the read-only annotation. However, it doesn't describe what the response looks like (no output schema provided), whether it includes period comparisons, or if it respects the company set via set_company. For a report tool, these are useful behavioral details.

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

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

The description is a single sentence with 11 words, no filler, and front-loads the key action and resource. Every word earns its place. Given the tool is simple (1 parameter, read-only), this is optimal conciseness.

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

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

For a simple 1-parameter read-only tool with 100% schema coverage, the description is adequate. However, without an output schema, it could benefit from mentioning what the balance sheet contains (e.g., assets, liabilities, equity) and whether it uses the currently set company/period from set_company/set_period. The current level is minimally complete but not informative beyond the tool's basic signature.

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

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

Schema coverage is 100% with one parameter (asOf) already described in the schema as 'As-of date in DD-MM-YYYY format'. The description adds no further semantics about the date meaning (e.g., whether it's the end date or an effective date). Since coverage is high, a baseline of 3 is appropriate – the schema carries the load, but the description misses an opportunity to clarify the date semantics.

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

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

The description uses a specific verb ('Get') and resource ('Balance Sheet') and adds a contextual qualifier ('from TallyPrime as of a given date'). It distinguishes itself from siblings like get_profit_and_loss and get_trial_balance by targeting a specific report type, but it doesn't explicitly differentiate from close siblings like get_bills_receivable. A 4 is given because the purpose is very clear but sibling differentiation is implicit rather than explicit.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., get_trial_balance or get_profit_and_loss). It does not mention prerequisites, typical scenarios, or related tools. With 27 siblings covering many Tally operations, this omission makes it harder for an agent to choose correctly.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the core behavioral trait is covered. The description adds that results are 'outstanding' and tied to a specific date, which is useful but limited. No additional traits (e.g., pagination, what 'outstanding' means) are disclosed. With annotations handling the safety profile, this is adequate but not exceptional.

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

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

A single sentence that starts with the core verb and resource, includes the key constraint ('outstanding', 'as of a given date'), and contains no extraneous words. Every part 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 tool with one parameter and no output schema, the description covers the essential purpose and filtering (date, outstanding status). It does not explain return format or provide examples, but given the low complexity, it is mostly adequate. Minor gap: missing what 'outstanding' means legally or in TallyPrime.

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 one parameter asOf has its own description). The tool description restates 'as of a given date', which aligns with the schema but adds no deeper meaning (e.g., date format, behavior if absent). With full schema coverage, a baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Get'), resource ('Bills Payable'), and scope ('outstanding ... as of a given date'), making it clear what the tool does. It naturally distinguishes from sibling tools like get_bills_receivable (which retrieves incoming bills) and other get_* tools.

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

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

No guidance is given on when to use this tool versus alternatives. For example, it does not note that get_bills_receivable should be used for outstanding receivables, or that get_vouchers might provide more granular transaction details. The description merely states the function without context for selection.

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

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

The description correctly implies a read operation, consistent with the readOnlyHint annotation. It adds the context that Bills Receivable are outstanding and date-specific. However, it does not detail what 'outstanding' means, whether the result is paginated, or if there are any limits, but given annotations handle the idempotency, a 3 is fair.

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

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

The description is a single, concise sentence that conveys the essential purpose without extraneous words. It front-loads the action and resource, making it efficient for an AI agent 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?

Given the tool has only one simple parameter (well-documented), a readOnly annotation, and no output schema, the description is adequate. It covers the core functionality, though it could be slightly more complete by clarifying what 'outstanding' entails or how the output is structured.

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 exactly one parameter (asOf) and its description in the schema is already clear: 'As-of date in DD-MM-YYYY format'. The description in the tool description does not add extra meaning beyond the schema's description. With 100% schema coverage, baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves 'outstanding Bills Receivable' from TallyPrime, as of a given date. It uses a specific verb ('get') and resource ('Bills Receivable'), and the as-of date condition distinguishes it from generic list tools.

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

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

The description implies the tool should be used to get outstanding bills receivable as of a specific date. However, it does not explicitly state when to use this tool versus sibling tools like 'get_bills_payable' or 'get_vouchers', nor does it mention any 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?

Annotations already declare readOnlyHint: true, so the safety profile is covered. The description adds beyond the structured data by disclosing the output shape ('DSPPERIOD/DSPACCINFO arrays as-is') and the fact that the report is confirmed live, which is meaningful behavior context for the agent.

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 cover purpose, reachability, liveliness, and output shape with no redundancy. The extra implementation detail (Export Data request) slightly lengthens the first sentence but is arguably useful context. Overall it is well-structured and 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 simple date-range read tool with no output schema, the description is sufficient: it states what it returns, the recognized report, and its availability. It could mention error handling or date invalidation, but such details are less critical given the annotation and 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?

Both parameters are fully described in the schema with DD-MM-YYYY format. The description merely restates 'date range' without adding extra meaning. Since schema coverage is 100%, a baseline of 3 is appropriate even though the description adds no parameter-specific details.

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') and a specific resource ('Cash Flow statement from TallyPrime') with a date range. It explicitly contrasts against the VAT/GST return reports, differentiating it from sibling report tools. No ambiguity about report type or 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?

It gives clear context: this is Tally's canned Cash Flow report, reachable via a plain Export Data request, and is confirmed live -- unlike the VAT/GST reports. This provides a when-to-use signal and excludes a class of alternatives, even though it does not name sibling tools like get_funds_flow.

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

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

Annotations already declare readOnlyHint=true, so the tool is safe. The description adds behavioral context by specifying 'currently open company info', implying session-dependent results, which is useful beyond what annotations provide.

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

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

The description is a single sentence of 8 words, perfectly front-loaded with the action and resource. Every word earns its place, with no unnecessary detail.

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

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

Given the tool has no parameters, no output schema, and annotations cover safety, the description provides all necessary context for an agent to decide to use it. It clearly communicates the tool's purpose and scope.

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

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

The tool has no parameters, so schema coverage is 100% by default. The description adds value by implying the tool returns company information without needing any input, which is appropriate for a parameterless 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 verb 'Get' and the resource 'currently open company info', which distinguishes it from sibling getters like get_ledgers or get_stock_items. No ambiguity.

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

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

The description implies the tool is used when company info is needed, but provides no explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives like set_company for context.

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

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

Annotations provide readOnlyHint=true and openWorldHint=false. Description adds no contradiction and is consistent. It does not elaborate further but is adequate given annotations.

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

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

Single, concise sentence. Front-loaded with action. No wasted words, though could be slightly more informative.

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 many sibling tools and no output schema, the description is minimal but works for a simple zero-param retrieval tool. Lacks detail on return structure, but annotations partially compensate.

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

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

Schema has zero parameters with 100% description coverage, so baseline is 4. Description adds no extra parameter info but is not 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?

States verb 'Get' and resource 'all cost centres from TallyPrime' clearly. However, it does not distinguish from sibling tools like get_groups or get_ledgers which also retrieve master data from TallyPrime.

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 vs alternatives like get_groups. No mention of scope or prerequisites.

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

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

Beyond the readOnlyHint annotation, the description discloses that the result is Tally's native monthly-period breakdown returned as-is, signaling no normalization or aggregation. The 'plain Export Data request' phrasing reassures that no complex operation is involved. Pagination or empty-range behavior could be mentioned, but annotations already cover the safety profile.

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

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

Two sentences with no filler; the first sentence carries the core purpose and the second adds behavioral output context. Information is front-loaded and each 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 two-parameter read-only report tool, the description covers what it is, its scope, the access method, and the expected return shape. No output schema exists, but the description compensates by describing the native monthly-period breakdown. Nothing essential is missing for an agent 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 100%, so both 'from' and 'to' already have format descriptions. The description only adds the notion of a date range, which is already implicit in the schema. Baseline 3 applies because the schema carries the parameter meaning.

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

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

States the specific action ('Get the Funds Flow statement') and resource ('from TallyPrime for a date range'). The note that it is Tally's own canned report helps differentiate it from custom or aggregated report tools among the siblings.

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

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

Implies this is the standard, direct Export Data route to Tally's Funds Flow report, but does not explicitly contrast it with related siblings like get_cash_flow or state when to prefer one. Some inference is required to choose among the many reporting tools.

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

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

Annotations already declare readOnlyHint=true (safe read) and openWorldHint=false. The description adds minimal extra behavioral context (source 'from TallyPrime') but does not disclose traits like response limits, auth requirements, or performance implications. It neither contradicts nor significantly enriches the annotations.

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

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

A single 14-word sentence that front-loads the core purpose. Every word earns its place—no filler, no repetition. Highly concise and well-structured.

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

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

Despite zero parameters and good annotations, the absence of an output schema means the description should explain what the returned data includes (e.g., group names, IDs, hierarchy). It does not, leaving an AI agent uncertain about the tool's output structure. For a simple list tool, some completeness 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?

With zero parameters and 100% schema coverage, the description correctly implies no input is needed. It adds no redundant parameter info. Per guidelines, zero parameters earns a baseline of 4, and the description meets that adequately.

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 'Get all account groups' with specific examples (Sundry Debtors, Fixed Assets), distinguishing it from siblings like get_ledgers or create_group. The verb+resource is explicit and unambiguous.

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

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

The description implies usage when a list of account groups is needed, but provides no explicit guidance on when to avoid this tool or alternatives. With siblings like get_ledgers and get_stock_items, the context makes differentiation possible, but the description itself lacks explicit exclusions or comparative context.

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

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

Annotations only provide readOnlyHint=true, so the description carries the behavioral burden. It discloses classification logic, the structural vs name_pattern tagging, why both signals are used, deliberate exclusions of non-liability ledgers, netTotal sign convention, reconstruction approach, and the explicit no-match note. This is far more than annotations alone provide.

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

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

The description is long, but almost every sentence adds necessary behavior or rationale for a nuanced accounting tool. It is front-loaded with the core purpose and then builds detail logically. Slightly verbose, but the detail earns its place for correct agent invocation.

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

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

There is no output schema, so the description must explain return semantics on its own. It covers row composition, classification tags, exclusions, sign convention, reconstruction approach, and the no-match behavior. For a tool with this complexity, the description is unusually 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%, with both from and to documented as start/end dates in DD-MM-YYYY. The description adds that the tool operates over a date range but does not add material semantics beyond the schema. Baseline 3 is appropriate since the schema already fully documents the parameters.

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

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

The description opens with a clear verb and resource: 'Get an India GST liability summary for a date range.' It goes beyond a generic statement by detailing what rows are returned and how they are classified, making it easy to distinguish from the VAT sibling and other reporting tools.

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

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

The description gives strong context for when to use this tool by referencing get_vat_liability_summary as the same design pattern and clarifying that this is rebuilt from ledger balances rather than a canned GSTR export. It does not explicitly state 'use X instead when Y', but the India GST scope and exclusions make the intended use clear.

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

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

The annotations already convey read-only safety, so the description's extra context—what the health check covers and that it reflects the current live state—adds real value beyond the structured fields. It clearly describes the diagnostic nature without contradicting readOnlyHint. It stops short of explaining failure modes or output shape, but the essentials are 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 compact sentences, with the core purpose front-loaded and the usage guidance following. Every clause adds distinct value: what the tool checks, when to call it, and what mistake it prevents. 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 zero-parameter health check, the description fully covers what the agent needs: the nature of the check, the exact information it reveals, and the circumstances in which it should be used. There is no output schema, but the listed health attributes give enough clarity about what to expect.

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

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

The tool has zero parameters, and the schema coverage is trivially 100%. The baseline for a 0-parameter tool is 4, and the description appropriately explains what the tool returns information about, so there is no missing 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 uses a specific verb and resource: 'Check whether this connector is actually safe and working right now.' It enumerates concrete aspects (gateway reachability, open company, TALLY_URL, read-only mode, disabled tools), immediately distinguishing it from all sibling tools, which mostly retrieve accounting data or perform mutations.

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

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

It explicitly tells an agent when to invoke this tool: 'Use this before trusting a session, or when something feels off.' It also warns against the alternative of inferring connector state from a single tool call's success/failure, which is actionable guidance for choosing this over other 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?

The description indicates a read-only 'get' operation, consistent with the readOnlyHint annotation. It adds that the output is a month-by-month summary, providing some behavioral detail beyond the annotation, though it does not mention potential side effects (which are none for a 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?

The description is a single sentence that efficiently conveys the tool's purpose, output format, and design reference. It is well-structured and contains no extraneous information.

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