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

With no annotations, the description still discloses key behavior: it is a mutation, only supplied fields are changed, and opening balance changes require a two-step approval flow where the first call returns current vs new values. It omits permission requirements, backup behavior, and other side effects, so it falls short of full 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?

Three compact clauses with no filler, and the most important behavioral nuance (two-step opening balance approval) is placed at the end of a front-loaded description. Every sentence earns its place.

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

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

The core mutation purpose and the non-obvious opening-balance approval workflow are covered. However, for a 25-parameter mutation tool with no annotations and no output schema, many parameter meanings and operational details remain absent, making it only minimally 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 only 40% across 25 parameters. The description names several fields and clarifies new_name and the opening_balance workflow, but leaves many parameters like email, phone, mobile, country, credit_days, dry_run, and extra_xml unexplained, so it does not compensate for the coverage gap.

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

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

States 'Modify a ledger' and enumerates the kinds of fields that can change, making the mutation purpose unambiguous. It does not explicitly distinguish itself from create_ledger or alter_master, but the verb/resource combination is clear.

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

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

The description implies use on an existing ledger and adds important partial-update semantics ('Only given fields change') plus the two-step opening-balance approval flow. It does not explicitly say when to choose this over create_ledger or alter_master, nor does it list prerequisites.

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

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

With no annotations, the description carries the safety/behavior burden. 'Only given fields change' usefully discloses partial-update semantics, but it does not mention permissions, reversibility, backup behavior, or what the response looks like.

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

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

Two sentences, front-loaded with the operation and scope. Every clause adds relevant information without repetition or filler.

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

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

For an 11-parameter mutation tool with no annotations and no output schema, the description is very thin. It omits dry-run behavior, backup implications, error/response expectations, and guidance on the less obvious parameters.

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

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

Schema coverage is 73%, close to the high-coverage baseline, and the schema already documents most parameters. The description reinforces partial updates but does not explain parameters such as new_name, extra_xml, or dry_run 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 gives a specific verb ('Modify / rename') and enumerates the exact master types handled. By listing account group, stock group, godown, unit, and cost centre, it distinguishes this tool from sibling tools such as alter_ledger and alter_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 listed master types imply when the tool applies, but the description gives no explicit guidance on when to use this instead of create_master, delete_master, alter_ledger, or alter_stock_item. Usage is inferable but not set out.

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

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

With no annotations, the description carries the full behavioral burden; it usefully discloses the non-obvious two-step opening-stock confirmation and that unspecified fields are left untouched. It never states that this writes to Tally and takes a backup, and it omits the dry_run safety path entirely even though the schema exposes it.

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 dense sentences, front-loaded with the field list and the highest-risk behavior. The opening-stock explanation is longer than the rest but earns its length; minor slack from the parenthetical field naming.

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 20-parameter mutation tool with no annotations and no output schema, the description covers the dangerous path but not the general return shape, the dry_run escape hatch, or the advanced XML extension point. Adequate to start, not adequate to call confidently.

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

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

It names new_name, group, unit, GST rate, HSN, description and opening stock plus the critical confirm_opening_change flag. But at 60% schema coverage, roughly half the parameters (aliases, category, cess_rate, extra_xml, taxability, opening_rate, opening_value, opening_godown, hsn_description, dry_run) get no meaning from either source.

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+resource ("Modify a stock item") and enumerates the updatable fields, which clearly separates it from create_stock_item and the master/ledger siblings. It doesn't explicitly name those siblings, so it falls just short of a 5.

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

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

"Only given fields change" establishes partial-update semantics and the opening-stock paragraph prescribes an exact procedure (call, show figures to user, repeat with confirm_opening_change). What's missing is any exclusion or pointer to create_stock_item / alter_master for adjacent operations.

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

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

With no annotations, the description carries the behavioral load and does so substantively: it discloses the field-level merge model, that ledger_entries/inventory_entries/stock_in/out REPLACE rather than append, that totals must still balance, and that existing single bill references are preserved automatically. These are non-obvious destructive semantics an agent must know. It omits return behavior and whether a backup is taken (only implied via the dry_run schema field).

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

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

Front-loaded with the verb and the identification key, then proceeds to the highest-risk semantics (replace behavior). Dense but each sentence carries information; not 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 an 8-parameter, deeply nested mutation tool with no annotations and no output schema, the description covers the critical mutation semantics that the schema cannot convey. The remaining gap is return-value/backup behavior, which is moderate but not disqualifying given the schema's dry_run hint covers side-effects.

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

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

Schema coverage is only 50%, but the description compensates on the highest-risk parameters: it clarifies the replace semantics of ledger_entries, inventory_entries, and stock lines, and the auto-retention of bill_allocations. It adds meaning genuinely beyond the schema for the `changes` object, though it says nothing about company, voucher_type, or the date/guid top-level params.

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 ('Modify an existing voucher') and names the identification key. It doesn't explicitly contrast with create_voucher/delete_voucher, but the mutate-existing framing distinguishes it well enough that an agent won't confuse it with creation or deletion.

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

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

Gives a preference signal ('master_id (preferred)') which is a partial usage cue, and explains that only fields in `changes` are touched. But there is no when-to-use vs alternatives guidance beyond that, and the other identification routes (guid, voucher_number+voucher_type) are not framed as fallbacks.

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

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

With no annotations, the description carries the full burden and does disclose the meaningful trait that output lands in 'Desktop\Tally Backups' as a copy. It omits whether an existing backup is overwritten, whether the operation is blocking for large datasets, and what the agent gets back on completion.

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

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

Two short sentences with the action and destination front-loaded and the automation caveat second. No filler, though the parenthetical path formatting is slightly awkward.

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

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

For a one-optional-param, no-output-schema tool this is close to sufficient: action, destination, and the key workflow caveat are all present. A brief note on overwrite behavior or confirmation would close the remaining gap.

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

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

Schema description coverage is 100% and the single optional 'company' parameter is fully documented there, including the omit-to-use-active-company default. The description adds no parameter-level detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Take a backup of the company data folder now') and names the destination, so the agent knows this is an immediate snapshot operation rather than a listing. It does not explicitly distinguish itself from the sibling list_backups, but the verb difference makes the distinction reasonably clear.

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

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

The sentence 'Write tools already do this automatically' is a genuine when-not-to-use signal: an agent can infer it should not chain a manual backup after create/alter calls. It gives no explicit positive trigger (e.g. before destructive operations), which keeps it 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?

No annotations are provided, so the description carries the full burden. It never states that this writes to Tally, that a backup is taken, that dry_run exists for previewing the XML, or that raw XML can be injected via extra_xml — all of which are behavioral traits an agent must know before a mutation call.

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

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

A single front-loaded sentence with zero waste, so nothing needs trimming. But the brevity reads as under-specification rather than discipline given the tool's 23-parameter surface.

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

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

A 23-parameter mutation tool with no annotations and no output schema gets one sentence of description. An agent has no way to know the write semantics, the dry-run option, or how the many optional fields behave — this is materially incomplete.

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

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

Schema description coverage is only 35% across 23 parameters, so the description must compensate, and it does not. The parenthetical hints implicitly at the required 'group' value space, but nothing is said about opening_balance/opening_type, GST fields, credit_days, or the dry_run preview path.

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 ledger') and the parenthetical examples (party, bank, expense, income, tax) clarify what a ledger group looks like, which is genuinely useful. It does not, however, distinguish this from create_master or alter_ledger, so an agent cannot route between them from the description alone.

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

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

No guidance on when to use this versus alter_ledger (existing ledger) or create_master (generic master creation), both of which are siblings. No prerequisites, no mention of the company context needed to target the right Tally instance.

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

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

No annotations are provided, so the description carries the full behavioral burden and does not meet it: it never says this writes to Tally, takes a backup, requires a parent for groups/godowns, or what happens on a duplicate name. The only hint of the mutation/backup behavior lives in the dry_run schema text, not the description.

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

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

A single front-loaded sentence with zero filler; the verb and the full type list come first and there is nothing to trim.

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?

Ten parameters, no output schema and no annotations make this the barest acceptable definition—the type list is covered, but parent/category/formal_name usage per type and the write/backup behavior are left to the schema or unaddressed. Adequate to invoke, thin for correct invocation on the less common types.

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 70% schema coverage the baseline is a 3, but the description adds genuinely useful semantics by clarifying that for units the name is the symbol (e.g. 'KG'), which is not obvious from the bare schema. It does not, however, explain how parent behaves for each of the five types.

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

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

States a specific verb (Create) plus an enumerated set of resources that maps one-to-one with the type enum, so an agent knows exactly what objects this produces. The enumeration also cleanly separates it from siblings like create_ledger, create_stock_item and create_voucher.

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?

Listing the five supported types implies when to reach for this tool versus the dedicated create_* siblings, but the routing is left to inference—nothing says 'use create_ledger for ledgers' or 'use alter_master to modify an existing one'. No prerequisites or exclusions are stated.

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

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

No annotations, so the description carries the full burden and it does not mention that this writes to Tally, that a backup is taken, or that dry_run exists for safe previews. For a mutation tool with real side effects this is a significant omission.

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 efficient sentence with no filler and no burying of key information. It is arguably too short rather than bloated, so conciseness itself is well handled.

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?

An 18-parameter mutation tool with no annotations and no output schema needs far more: validation rules, defaults, units prerequisite, dry_run workflow, and what a successful response contains. The description is a field list, not an operational brief.

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

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

The description names roughly 5 of 18 parameters and only restates schema field names rather than adding meaning. With schema coverage at 56%, the undocumented half (aliases, cess_rate, taxability, extra_xml, opening_godown, dry_run) receives no compensating explanation in the description.

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

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

Specific verb ('Create') plus resource ('stock item') and it enumerates the salient fields, so the agent knows exactly what will be produced. It stops short of differentiating itself from siblings like create_master or alter_stock_item, which is a meaningful ambiguity here.

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

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

No statement of when to use this versus alter_stock_item, create_master, or import_raw_xml, all of which could plausibly create master data. No prerequisites (e.g. unit must exist first) appear in the description, only buried in the schema for one parameter.

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

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

With no annotations, the description carries the full behavioral burden and does a good job disclosing key domain rules: Debits must equal Credits, item direction is Cr for sales and Dr for purchases, and GST is not auto-computed. It does not mention operational traits such as authentication needs, failure modes, or whether creation is reversible, but the core accounting behavior is well explained.

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 action and then uses dense, purposeful sentences to cover accounting vouchers, item invoices, stock journals, and GST treatment. Every sentence carries useful guidance for one of the major modes, with no filler.

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

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

For a complex 15-parameter creation tool with no annotations and no output schema, the description covers the essential accounting modes, balancing rule, item direction semantics, and GST caveat. It leaves out some operational details like dry-run behavior, backup implications, and failure/validation expectations, but the schema covers many of those parameter-level details.

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

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

Schema description coverage is high (87%), and the description still adds meaningful semantics by explaining how ledger_entries, inventory_entries, stock_in, and stock_out differ by voucher category. It also clarifies that CGST/SGST/IGST must be passed as explicit ledger lines, which is beyond the schema's parameter-level 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 states a specific verb and resource: 'Create a voucher in Tally', and enumerates the supported voucher categories (Payment, Receipt, Journal, Contra, Sales, Purchase, etc.). It is clear what the tool does, but it does not explicitly distinguish itself from sibling tools like alter_voucher, delete_voucher, or import_raw_xml.

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 conditional guidance for payload shape based on voucher category: accounting vouchers need ledger_entries, item invoices need inventory_entries plus party/tax ledgers, and stock journals need stock_in/stock_out. It does not explicitly say when to use this tool versus alter_voucher or delete_voucher, nor does it name prerequisites.

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

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

With no annotations, the description carries the full burden and does so: permanent/deleting nature, backup taken first, Tally-side refusal when referenced by vouchers, and the confirmation gate are all disclosed. This is exactly the behavioral context an agent needs before a destructive call.

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

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

Three tight sentences, front-loaded with the destructive scope before the caveats. No filler; each sentence adds either scope, failure mode, or the confirmation requirement.

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 master tool with no output schema, it covers consequences (permanence, backup, refusal conditions) and the confirmation gate. Minor gap: it never points to list_backups or explains where the backup lands, nor mentions dry_run for safe rehearsal.

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 60%, and the description mostly restates what the schema says ('Requires confirm: true' duplicates the schema's 'Must be true'). It never mentions the dry_run escape hatch or the company parameter, which would have been meaningfully additive.

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 ('Permanently delete') plus an enumerated set of resources and distinguishes itself from the delete_voucher / alter_master siblings by naming exactly which master types it covers. An agent can route here without inspecting 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 a clear precondition ('Requires confirm: true') and a process instruction ('get the user's approval first'), plus an implicit precondition that the object must be unused. It does not explicitly say when to prefer alter_master or create_master, so sibling exclusions are only implied.

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

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

With no annotations, the description carries the full safety burden and does well: it says the deletion is permanent, a backup occurs first, confirm must be true, and prior user approval is required. It does not cover failure behavior, permissions, or dry-run preview, leaving some behavioral gaps.

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

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

The description is short and front-loaded with the destructive action and backup behavior, followed by identification and approval requirements. Every sentence contributes to safe 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?

For an annotation-free destructive tool, it covers the most critical context: permanence, backup, confirmation, and approval. It omits dry_run and does not fully explain all eight parameters, but the schema documents several of those details.

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

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

Schema coverage is 63%, and the description mainly repeats schema-provided semantics for master_id (preferred) and confirm: true. It does not clarify the roles of guid, voucher_type, voucher_number, or when to use each identifier, so it adds limited meaning beyond the schema.

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

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

The description states a precise verb and resource: permanently delete a voucher from Tally. It also discloses the irreversible nature and that a backup is taken first, which clearly distinguishes it from non-destructive sibling tools.

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

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

It gives explicit preconditions: show the user the voucher via get_voucher, get approval, and require confirm: true. It also recommends master_id for identification. It does not name when-not-to-use or alternative deletion workflows, 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?

With no annotations, the description carries the full behavioral burden. Its main contribution is disclosing the return payload per master type (Ledger: opening balance, GSTIN, PAN; Stock item: GST rate, HSN), which is real value given no output schema exists. However, it says nothing about missing-record behavior, read-only safety, or cost, and the 'Others: parent etc.' clip is vague.

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

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

Front-loaded with the core purpose, then efficiently enumerated by type in a compact telegraphic style. It's dense but not padded; the only weak spot is the trailing 'Others: parent etc.', which trails off rather than informing.

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

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

Because no output schema exists, this description is the sole source of return-value information and it does cover two of the seven types in detail. But four master types are collapsed into 'Others: parent etc.', leaving the most unusual enum values largely 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 coverage is only 33%, so the description should compensate for the undocumented 'name' and 'type' semantics. It partially does by mapping the 'type' enum values to their resulting field sets, but says nothing about how 'name' is matched (exact vs fuzzy) or what 'Others: parent etc.' means for group/stock_group/unit/godown/cost_centre.

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 it returns 'full details of one master', which distinguishes it from the sibling list_masters by the singular scope. The breakdown of fields by master type (ledger, stock item) reinforces what 'details' means. It stops short of naming the sibling it replaces, which is why it isn't a 5.

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

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

There is no explicit 'use this when...' statement or named alternative; the reader infers from 'one master' that this is the single-record counterpart to list_masters. No prerequisites, no exclusions, no guidance on when get_master is preferred over list_masters with a filter.

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

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

No annotations are provided, so the description bears the full burden. 'Get' implies read-only behavior, but the description does not disclose permission/auth needs, behavior when identifiers are missing or ambiguous, company-context effects, or what 'in full' returns beyond the vague phrase.

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. The parenthetical packs alternative identifier combinations efficiently without obscuring the main purpose.

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

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

The tool has 7 parameters, no required parameters, no annotations, no output schema, and only 57% schema description coverage. The description identifies lookup keys but does not explain return values, company context, include_xml behavior, or error/ambiguity handling, leaving significant gaps for an agent invoking 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 description adds useful retrieval-key semantics, especially the combined date + voucher_number + voucher_type alternative, which the schema does not explicitly group. With 57% schema description coverage, the schema already documents several parameters, and the description does not add meaning for company or include_xml beyond what the schema provides.

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

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

The description states a specific verb and resource: 'Get one voucher in full.' It clearly distinguishes single-voucher retrieval from list_vouchers implicitly, but does not explicitly name the sibling alternative or contrast with get_master.

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 lists accepted lookup keys (master_id, guid, or date + voucher_number + voucher_type), which implies how to invoke the tool. However, it does not say when to use this versus list_vouchers or get_master, nor does it state prerequisites or preferred workflow beyond 'master_id' being preferred in the schema.

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

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

With no annotations, the description carries the full behavioral burden. It reveals that raw XMl can perform Create/Alter/Delete actions, which signals mutation and possible destruction, but it does not mention backup behavior, validation bypass, permissions, or irreversibility; the dry_run safety detail exists only in the schema.

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

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

The description is a single, compact, front-loaded sentence. It establishes the escape-hatch role first, then gives concrete XML examples, and ends with the routing preference, with no wasted text.

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

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

For an advanced raw-import tool, the description does enough to route the agent correctly and clarify the XML payload shape. The schema covers parameters and dry_run behavior, but the description itself omits safety details that would matter for a destructive raw import path.

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 four parameters. The description repeats the <TALLYMESSAGE> placement context and adds XML examples, but does not add meaning about report selection, company scoping, or dry_run beyond what the schema provides.

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

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

States a specific verb and resource: import raw Tally XML objects, specifically the content inside <TALLYMESSAGE>, with examples such as <VOUCHER> or <LEDGER>. The phrase 'Advanced escape hatch' and 'Prefer the specific tools' clearly distinguishes it from the many create/alter/delete sibling tools.

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

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

The description gives clear fallback guidance: this is an advanced escape hatch and callers should prefer the specific tools. It does not name those sibling tools explicitly or spell out precise exclusion cases, but the intended usage is still 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that results are newest-first and include folders, and 'List' implies a read-only operation, but it omits permission requirements, rate limits, and any caveats about automatic versus manual backups.

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

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

The description is a single, front-loaded sentence with no wasted words. Ordering and contents are stated efficiently.

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

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

Given zero parameters and no output schema, the description provides enough to understand the result shape: backups listed newest first, including folders. It could be slightly more complete by mentioning pagination or empty-result behavior, but the tool's complexity is low.

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

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

The tool has zero parameters, so there is no parameter semantics to explain. The baseline for a zero-parameter tool is 4.

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

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

The description states a specific verb and resource: list data backups. It also clarifies scope (automatic/manual), ordering (newest first), and included data (folders), which distinguishes it from sibling tools like backup_data and the other 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 listing purpose implies inspecting existing backups, but the description does not explicitly say when to use this tool versus backup_data or other sibling tools. Usage is only implied by the verb and resource.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the sign convention of the returned balances (positive = Cr, negative = Dr), which is real value beyond the schema, but it says nothing about read-only safety, result volume, pagination, or what happens when the active company is omitted.

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 dense sentence with the resource and the return shape front-loaded and zero filler. Nothing could be removed without losing information.

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

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

For a simple three-optional-parameter list tool with no output schema, the description conveys the key return fields (group, opening/closing balance) and their sign convention, which is the main thing an agent needs. It stops short of explaining volume or default ordering.

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 all three optional parameters are already documented with examples and semantics (group includes sub-groups, search is case-insensitive, company defaults to active). The description adds no parameter-level meaning, so the baseline 3 applies.

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

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

The description states a specific verb (list) and resource (ledgers) and adds what each row contains: group plus opening/closing balance. An agent can tell it apart from get_master or list_masters, but the description does not explicitly contrast those siblings.

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

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

There is no when-to-use, when-not-to-use, or alternative routing guidance; the agent must infer that this is the read path from the verb 'list' alone. Nothing says when to prefer this over list_masters or get_master.

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

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

With no annotations and no output schema, the description carries the full burden, yet it only discloses one behavioral trait: that ledger and stock_item results contain names only. It says nothing about the return shape for other types, ordering, pagination, or whether the read is scoped to the active company.

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

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

A single front-loaded sentence with the type list and the key caveat early; no wasted text. The trailing parenthetical is slightly cryptic but does earn its place by flagging the names-only limitation.

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 four-parameter read tool with no annotations and no output schema, the description omits the return shape for most types, the purpose of 'search' and 'parent' filtering, and any redirect to the richer sibling tools. An agent could call it, but with avoidable guesswork.

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

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

Schema coverage is only 50%, and the description adds no meaning for the undocumented parameters (notably 'search', which has no schema description). It restates the enum values for 'type' rather than explaining filtering semantics, so it does not compensate for the coverage gap.

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

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

States a clear verb+resource ('List masters of a type') and enumerates the valid types, which lets an agent distinguish it from list_vouchers or list_backups. The parenthetical 'also ledger / stock_item, names only' partially separates it from list_ledgers and list_stock_items, though the distinction is terse.

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

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

The phrase 'names only' for ledger/stock_item implies those richer sibling tools (list_ledgers, list_stock_items) should be used when more than names is needed, but the description never names them or states when not to use this tool. Usage is inferable but not explicit.

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

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

With no annotations, the description carries the full behavioral burden, but 'List' only weakly implies a read operation. It says nothing about permissions, pagination, result size limits, or whether an empty result is possible – all material for an unannotated 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?

A single front-loaded sentence that names the tool's scope and returned fields with no filler. It is efficient, though its brevity is part of the completeness problem rather than a virtue.

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?

Mentioning the returned fields partially substitutes for the missing output schema, which helps. However, the unannotated safety profile and the unexplained 'search' parameter leave real gaps for a two-parameter tool.

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

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

Schema description coverage is only 50%, and the undocumented 'search' parameter is left unexplained in the description – no indication of which fields it matches or whether it is a substring or exact match. The description does not compensate for the schema gap.

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

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

States a specific verb and resource ('List stock items') and enumerates the returned fields (group, base unit, closing quantity/value), which distinguishes it from sibling list tools like list_ledgers and list_vouchers. It doesn't explicitly contrast against list_masters, though the stock-item focus is clear.

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

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

There is no guidance on when to use this tool versus alternatives such as list_masters or get_master, and no prerequisites or exclusion conditions are stated. An agent must infer usage entirely from the name and description.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses a concrete performance cost (~5 seconds per month of data) and the shape of each returned row (master_id). It stops short of covering truncation behavior when the limit is hit or confirming read-only semantics, so it is strong but not complete.

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

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

Three short sentences with no filler: purpose first, then the identifier an agent needs downstream, then the performance caution. Every sentence earns its place and the most actionable constraint is front-loaded after the purpose.

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

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

For an 8-parameter list tool with no output schema, the description covers purpose, cost, and the critical return field, which is most of what an agent needs. The remaining gap is what happens when results exceed the default limit of 200 or the 2000 cap, which affects result interpretation.

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 (from/to formats, item/ledger contains-matching, search fields, limit default, company fallback, exact voucher_type) is already documented in the schema. The description adds no per-parameter meaning beyond framing the date range, 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 ('List vouchers') plus the scope (date range) and the payload ('with their entries'), which distinguishes it from the single-record get_voucher sibling. It also names the key field returned (master_id), so an agent knows what it gets back without opening a schema.

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

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

Usage is implied rather than stated: 'keep ranges short' is a real constraint on how to call it, and the master_id note hints at a list-then-mutate workflow with alter_voucher/delete_voucher. But there is no explicit when-not-to-use guidance and no routing to alternatives such as get_voucher for a single voucher or list_voucher_types for type discovery.

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

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

No annotations exist, so the description carries the full burden. It partially compensates by showing the returned shape (name -> base type mapping), but says nothing about permissions, company scoping behavior, pagination, or whether the list is paginated or complete.

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

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

A single sentence with the resource and the value-add (base type mapping) front-loaded; the inline example does real work in place of more prose.

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, optional-parameter read tool with full schema coverage and no output schema, this is nearly sufficient; only enumeration-volume or ordering behavior is unstated, which is a minor gap.

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

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

Schema coverage is 100% — the single `company` parameter is fully documented in the schema, including the omit-to-use-active-company behavior. The description adds no additional parameter detail, so baseline 3 applies.

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

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

The description states a specific verb and resource ("List voucher types with their base type") and the example clarifies what a returned item looks like. It is clearly distinct from list_vouchers, though it doesn't explicitly say so to the agent.

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 list_vouchers, list_masters, or get_master, nor any prerequisites or exclusions. The agent must infer usage from the name alone.

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

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

No annotations exist, so the description carries the full burden. It discloses what the call surfaces (connection state, loaded companies, backup settings), which implies a read-only diagnostic, but never states that explicitly nor describes what a failed connection returns or whether the call is side-effect free.

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

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

A single front-loaded sentence with a clear verb ('Check') and no filler. Every clause identifies a distinct output of the 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?

With no output schema and no annotations, the description must convey return shape, and it only names the three outputs at a high level. It leaves unclear how 'backup settings' relates to the sibling list_backups/backup_data tools and what the response looks like when the connection is down.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter semantics to compensate for.

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

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

States three concrete operations: connectivity check to TallyPrime, listing loaded companies, and surfacing backup settings. This clearly distinguishes it from the create_/alter_/list_* siblings, though the combination of three distinct outputs in one tool blurs the single-resource framing.

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

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

Usage is implied rather than stated — an agent can infer this is a diagnostic/preflight tool to run before other operations, but the description never says when to call it or that it should precede the mutating siblings. No alternatives or exclusions are named.

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