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

With no annotations, the description carries the full burden for behavioral disclosure. It does mention the effect (can receive real transactions) and implies a state change (activating), but it does not disclose side effects, reversibility, permissions, or behavior on already active budgets. Some context is added, but significant gaps remain.

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 key information. However, the parenthetical '(action_activate)' adds unnecessary noise and could confuse agents, so it loses a point for structure.

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 tool with one parameter and no output schema, the description gives the core purpose and effect, but it lacks parameter semantics and explicit workflow guidance relative to siblings like 'approve_budget' and 'budget_vs_actual'. It is minimally viable but leaves gaps.

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

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

The input schema has one parameter 'budget_id' with no description (0% schema coverage), and the description does not explain what this ID refers to, how to obtain it, or any constraints. Although the parameter name is somewhat self-explanatory, the description adds no semantic value beyond the schema.

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

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

The description clearly states the tool's action (activate) and its resource (an approved budget), and it specifies the purpose (so it can receive real transactions). This distinguishes it from sibling tools like 'approve_budget' and 'submit_budget' by indicating the budget must already be approved and the activation is the final step before real transactions.

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 by requiring the budget to be 'approved', implying this tool is used after 'approve_budget' and before transactions occur. However, it does not explicitly exclude alternatives or state what happens if the budget is not approved, so it falls short of full usage guidance.

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

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

With no annotations, the description carries the burden. It discloses that only open balances are included and that results are bucketed by days overdue as of a date. However, it does not mention whether the tool is read-only, what the exact output structure is, or any limitations such as pagination.

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

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

The description is a single concise sentence that fronts the key concept 'Aged payable' and includes the essential details: open balances, bucketing by overdue days, and as-of date. No unnecessary 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?

Despite a simple two-parameter schema, the lack of annotations and output schema means the description must explain the return format and parameter semantics more thoroughly. It only vaguely describes the output as bucketed balances and omits partner filtering behavior, making it incomplete for an agent to know exactly 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?

Schema description coverage is 0%, so the description must compensate. It explains as_of_date via 'as of a date' but the partner_id parameter is not mentioned or described. The meaning of partner_id as a vendor filter is not provided, leaving the agent to infer from the parameter name.

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 reports open vendor bill balances grouped by overdue day buckets. It distinguishes itself from sibling aged_receivable by specifying vendor bills, and from generic invoice search tools by the aging/bucket focus.

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

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

The description implies this tool is used for vendor payable aging reports, but it does not explicitly state when to use it over alternatives like aged_receivable or search_invoices. No exclusions or alternative recommendations are provided.

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

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

With no annotations, the description must carry behavioral disclosure. It explains that balances are open customer invoices, bucketed by overdue days as of a date, which conveys read-only reporting behavior and reporting scope. However, it does not clarify whether 'open' means unpaid/unreconciled or how partner filtering interacts with the aging buckets.

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 is front-loaded with the tool name and immediately states what the tool returns. No filler or redundant content.

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

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

For a simple aging report with two parameters and no output schema, the description covers the main output (open customer invoice balances in aging buckets) and the effective date. It omits partner_id semantics and any return format details, but overall it is reasonably complete for a report tool.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'as of a date' for the as_of_date parameter, but gives no explanation of partner_id, which is optional and could be used to filter the report. Thus, partner_id semantics are entirely undocumented.

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

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

The description clearly identifies the tool as an aged receivable report: it lists open customer invoice balances bucketed by days overdue as of a date. This distinguishes it from sibling tools like aged_payable (vendor side) and search_invoices, though it lacks an explicit verb like 'retrieves' or 'lists.'

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

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

The description implies this is the tool for obtaining customer receivable aging reports, but it does not state when to prefer it over alternatives such as aged_payable or search_invoices. No exclusions or conditions are given.

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

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

With no annotations, the description must disclose side effects, permissions, and irreversibility, but it only states the action 'Approve'. It does not mention what happens after approval, whether it is reversible, or any required permissions.

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

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

The description is a single, front-loaded sentence with no wasted words. However, it is under-specified for an agent with no annotations or output schema, so it does not fully earn 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 tool has a simple one-parameter schema but no annotations or output schema. The description lacks workflow context, behavioral details, and any explanation of the action's effects, making it incomplete for reliable tool invocation.

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

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

Schema description coverage is 0%, and the description only references 'budget' without explaining the budget_id parameter. The inference is that budget_id selects the submitted budget, but no additional details on the parameter's meaning or constraints are provided.

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 'Approve' and the resource 'submitted budget', which distinguishes it from siblings like submit_budget and activate_budget. It also includes the technical action 'action_approve' which adds specificity.

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 word 'submitted' implies this tool is used for budgets in the submitted state, but no explicit when-to-use guidance or mention of alternatives is provided. The workflow position is only implied, not stated.

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

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

Description discloses that it computes cumulative balances from posted journal items only, and uses a specific as_of_date cutoff. Given no annotations, this provides useful behavioral context, but it does not mention return format or any permissions/errors.

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

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

Single sentence, front-loaded with the report name, and packs essential details without unnecessary 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?

The description covers the report's purpose, date scope, and data source (posted items), which is adequate for a simple read-only report. However, it omits behavior for optional company_id and does not describe the output structure, though that may not be critical.

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 no parameter descriptions and description covers only the as_of_date parameter (cumulative up to that date). The optional company_id parameter is not explained in the description, leaving its semantics unclear.

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 identifies the tool as generating a balance sheet (assets/liabilities/equity) as of a specific date, distinguishing it from sibling reports like profit_and_loss. It specifies the source (posted journal items) and computation method (cumulative balances).

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 for balance sheet reporting but does not explicitly state when to use this over sibling reports like trial_balance or profit_and_loss. There are no exclusion criteria or alternative references.

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 behavior transparency burden. It discloses that all values are read directly from Odoo's computed fields and never recalculated, which is a meaningful behavioral trait. It also implies a read-only operation, though it does not cover error handling or authorization.

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, well-structured sentence that front-loads the tool's purpose and lists the key output components. No redundant filler; every phrase adds value.

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 details exactly what the summary includes (per line and totals for five cost metrics) and clarifies data provenance. Given the tool's simplicity and one parameter, this is reasonably complete, though it omits any explanation of the response structure or error behavior.

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

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

The schema has only one parameter, budget_id, with no description in the schema. The tool description ties it to 'one budget,' which provides minimal contextual meaning. Since the parameter is self-explanatory as an identifier, the description adds just enough for the agent to select the right budget, but not much beyond that.

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 specifies a budget-vs-actual summary for one budget, enumerating the exact fields returned (planned cost, actual cost, ETC, EAC, available budget). It distinguishes itself from sibling tools like search_budget_lines and get_budget by focusing on the variance analysis summary.

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

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

The description makes the tool's use case evident: retrieve a budget-vs-actual comparison from Odoo's computed fields. However, it does not explicitly state when to use this over alternatives (e.g., search_budget_lines) or any exclusion conditions, so guidance is only implied.

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

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

With no annotations, the description carries the burden of explaining behavior. It discloses the mutually exclusive cost entry methods (quantity-based vs. lump sum), which is a key behavioral rule not obvious from the schema. It does not mention error handling or side effects, but the essential behavioral trait is covered.

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

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

The description is two sentences long, front-loaded with the primary action, and contains no filler. Every word earns its place, efficiently conveying the purpose and the key cost-modeling choices.

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 creation tool with 14 parameters and no output schema, the description covers the core ambiguity (how to specify costs) while other parameters are reasonably inferable from their names. It does not explain required-field prerequisites or return values, but for a create operation this is a reasonable level of completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful context for cost-related parameters (planned_qty, planned_unit_cost, is_lump_sum, planned_total_cost) by explaining their relationship. However, the remaining 10 parameters (e.g., uom_id, boq_code, analytic_account_id) are left entirely to their names, which are self-explanatory but lack depth.

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 'Add' and the specific resource 'a new BOQ line to a budget'. It distinguishes this creation tool from siblings like update_budget_line and search_budget_lines by emphasizing it creates a new 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 on when to use this tool (when adding a new line) and gives specific guidance on how to set costs: either planned_qty + planned_unit_cost or is_lump_sum=True with planned_total_cost. However, it does not explicitly mention alternatives like update_budget_line for existing lines.

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 transparency burden. It discloses the key behavioral trait that the invoice is always created in draft and requires a follow-up call to post_invoice(). It also details the required structure of the 'lines' parameter, providing useful behavioral context 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?

The description is efficiently structured: a purpose sentence, parameter breakdown, and a note on the draft workflow. Every sentence adds necessary information without fluff or repetition, making it highly concise.

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

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

The description covers the essential parameters and the draft behavior, but it omits an explicit note about the return value (e.g., created invoice ID) and does not explain optional fields like company_id or journal_id. However, given the schema and the tool's simplicity, it is largely complete for agent use.

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

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

Schema description coverage is 0%, so the description compensates well for the most complex parameters: move_type is fully enumerated with meanings, and lines is described with required and optional fields. Other parameters (partner_id, ref, company_id, etc.) are not explained, but their names are self-explanatory and the description adds value where needed most.

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 function with a specific verb and resource: 'Create a DRAFT customer invoice or vendor bill.' It further distinguishes between customer invoices, credit notes, and vendor bills/credit notes via the move_type parameter, making it distinct from sibling tools like create_journal_entry.

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 usage context by noting that invoices are always created in draft and instructing to call post_invoice() to post. This implies the workflow and differentiates from posting tools, but it does not explicitly name alternatives or state when not to use this tool.

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

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

With no annotations, the description carries the burden of disclosure. It provides useful behavioral details: the entry is a draft, move_type is 'entry', and balancing is enforced only on post ('Odoo enforces this on post'). This goes beyond basic create semantics, though it omits return values and error handling.

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, with the main purpose front-loaded in the first sentence. The subsequent lines explanation is dense but necessary for parameter understanding, and there is no redundant content. Slightly less concise due to the structured layout, but overall efficient.

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

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

The description adequately explains the tool's function and the critical balancing rule, but lacks information about return values, error conditions, or how to obtain valid IDs (journal_id, account_id). For a create operation with no output schema, this leaves some gaps in actionable understanding.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains the 'lines' parameter structure, but leaves 'journal_id', 'date', 'ref', and 'company_id' undocumented. Thus only one parameter is given meaningful semantics, while the others rely solely on type 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 explicitly states 'Create a DRAFT manual journal entry (move_type='entry')' which clearly identifies the action (create), the resource (journal entry), and the state (draft). This differentiates it from siblings like post_journal_entry or create_invoice, making the 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?

The description implies usage context by emphasizing 'DRAFT' and 'manual', suggesting this tool is for creating draft entries rather than posting or reversing. It does not explicitly name alternatives, but the draft designation provides enough context for when to use 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?

With no annotations, the description carries full behavioral burden. It clearly states the tool only returns 'posted' journal items, limited to one account and a date range, sorted by date, and includes a running balance. However, it omits details like permissions, empty-result behavior, and the exact nature of the running balance (opening vs. cumulative).

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 entire description is a single, well-structured sentence that front-loads the core purpose and key attributes (posted items, account, period, ordering, running balance). Every phrase carries information with no redundancy.

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

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

The description gives a solid high-level overview but lacks output schema and annotations, leaving gaps about the exact fields returned, date inclusivity, and handling of accounts with no activity. It is adequate for tool selection but not fully sufficient for understanding precise return semantics.

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

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

Schema coverage is 0% and the description provides only a vague paraphrase: 'one account for a period' maps to account_id and date range but does not clarify date formats, value constraints, or the precise role of each parameter. The description adds minimal value beyond the parameter names themselves.

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 what the tool returns: all posted journal items for one account over a period, in date order, with a running balance. This clear, specific scope distinguishes it from sibling reports like trial_balance or profit_and_loss, which aggregate differently.

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

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

The description implies use when an account-level transaction list with running balance is needed, but it provides no explicit 'when to use' guidance or mention of alternatives like search_journal_entries or trial_balance. Usage context is only inferred from the tool's function.

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

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

No annotations are provided, so the description carries the burden. It discloses that the data is 'read directly from Odoo, never recomputed here', which is a useful behavioral trait indicating a read-only, source-aware operation. However, it omits other relevant details like error handling, return format, or permission requirements, so it provides only partial 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 a single, well-structured sentence that front-loads the core purpose ('Full detail of one budget') and then expands with specific content and a behavioral note. Every part adds value, and there is no redundancy 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?

Given the absence of an output schema, the description does a good job of summarizing the return content by mentioning 'every BOQ line with its planned/actual/ETC/EAC figures'. However, it does not address how the budget is identified in practice or what happens if the budget does not exist, leaving some contextual gaps.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining the budget_id parameter. The schema only provides 'Budget Id' with an integer type, which is self-explanatory, but the description adds no extra context about the meaning, format, or source of the ID. Since the description must compensate for low coverage and does not, the score is low.

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 returns 'Full detail of one budget, including every BOQ line with its planned/actual/ETC/EAC figures', which is a specific verb+resource+scope. It distinguishes itself from sibling tools like list_budgets (which lists budgets) and budget_vs_actual (which compares budgets), by focusing on a single budget's full detail.

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 complete budget detail is needed, but it does not explicitly mention when to use this tool over alternatives or provide exclusions. No guidance is given on conditions where other tools would be more appropriate, so usage context is only implied.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the result includes full detail and lines, which is useful, but it does not explicitly mention read-only behavior, error handling, or authentication requirements. For a simple getter, the description provides basic but not rich behavioral context.

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

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

The description is one concise sentence, immediately states the main purpose, and contains no unnecessary filler. It is optimally front-loaded and every word contributes value.

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

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

With no annotations, no output schema, and no parameter coverage, the description is too sparse for a complete tool understanding. It does not specify return fields beyond 'lines', does not clarify how to obtain the move_id, and gives no error or prerequisite context. The simple structure does not fully compensate for these gaps.

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

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

Schema description coverage is 0% and the description does not explain the move_id parameter or its relationship to the invoice/bill. The schema only shows an integer ID titled 'Move Id', which may be ambiguous for agents unfamiliar with Odoo's account.move model. The description fails to compensate for the lack of parameter documentation.

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 provides full detail of a single invoice/bill including lines, which is a specific retrieval operation. It distinguishes from siblings like search_invoices by emphasizing 'one invoice' and 'including its lines', effectively communicating scope and resource.

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

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

The description implies use when full detail of one invoice is needed, but it does not explicitly state when to use this tool versus search_invoices or other siblings. There are no clear exclusions or alternative recommendations, so usage context is only implied.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'List' indicates a read-only operation, and the filter examples add context. However, it does not explicitly mention response format, pagination, or whether budget lines are included. This is a moderate gap, but the core behavior is clear.

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 redundant words. It conveys the essential verb, resource, and filter options efficiently, earning a perfect score for 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?

Given the low complexity of a list operation, the description is fairly complete. It specifies the actionable resource and filters. However, without an output schema, it does not describe the return value shape (e.g., fields returned, whether empty results are possible). This minor gap prevents a perfect score.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'project_id' and 'state' by saying 'optionally filtered by project and/or state' and gives examples for 'state'. However, it omits any mention of the 'limit' parameter, which remains unexplained. This partial compensation warrants a score of 3.

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 'List' and the resource 'project budgets', with optional filters by project and state. It distinguishes from sibling tools like 'search_budget_lines' (which targets budget lines) and 'get_budget' (which retrieves a single budget), making its purpose specific and unambiguous.

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

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

The description implies when to use the tool: to list project budgets with optional filters. It provides clear context for listing operations but does not explicitly exclude or compare with alternatives like 'get_budget' or 'search_budget_lines'. Since no such exclusions are stated, it earns a 4 rather than 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?

With no annotations, the description carries full burden. It mentions that 'ids may be empty for @api.model methods' which is a helpful nuance, but it fails to disclose the potential for arbitrary side effects (writes, deletions) or what the return value looks like. As a 'universal escape hatch,' it should warn about the power and risks, especially since it can call ANY method.

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 four short sentences with a clear front-loaded purpose and concrete examples. No filler or repetition; every sentence adds useful information, making it easy to scan and understand.

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

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

For a tool with no annotations, no output schema, and 5 parameters, the description is incomplete. It omits any guidance on what the method call returns (e.g., a dict, boolean, record IDs), how errors are surfaced, or whether authentication/privileges are needed. The generic 'any method' nature demands more cautionary 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?

The schema has 0% description coverage, so the description must compensate. It clarifies the first three parameters via examples (model, method, ids) and the empty-id case, but it says nothing about 'args' and 'kwargs' or how they map to positional/keyword arguments. This is partial compensation but leaves key parameters underspecified.

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 purpose: 'Call ANY method on an Odoo model -- the universal escape hatch.' This distinguishes it from sibling tools that wrap specific operations, and examples like odoo_call_method("account.move", "button_draft", [123]) make the scope 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 explicitly tells when to use this tool: 'Use this for workflow actions the dedicated tools don't wrap yet.' This provides clear direction relative to the many sibling tools, implying dedicated tools should be preferred for their specific cases.

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

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

With no annotations, the description carries the full burden. It discloses that exactly one record is created, returns the new ID, and warns that accounting documents need dedicated tools for correct line/tax/journal setup. It doesn't cover error handling or permissions, but for a generic create operation this is adequate behavioral 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 three concise sentences: purpose, example, and usage guidance. Every sentence earns its place, with no filler or repetition. It is front-loaded with the core purpose first.

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

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

Given the tool's generic nature (any model), no output schema, and no annotations, the description provides a solid foundation: purpose, example, return value, and sibling disambiguation. It lacks error-handling details, but the core functionality is sufficiently covered for an agent to invoke correctly.

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

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

Schema coverage is 0%, so the description must compensate. It does so with a concrete example: odoo_create("res.partner", {"name": "Acme LLC"}). This illustrates that 'model' is a string (e.g., res.partner) and 'values' is a dictionary of field values. This adds meaning beyond the raw schema fields.

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

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

The description clearly states the action: 'Create ONE record on any model' and specifies that it returns the new record's ID. This is a specific verb+resource combination that distinguishes it from sibling tools, especially since it explicitly contrasts with dedicated accounting 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 usage guidance: avoid for accounting documents, use dedicated accounting.* tools instead, and use this tool for 'anything they don't cover.' This directly addresses when to use and when not to use, naming specific 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?

No annotations are present, so the description carries the full burden. It lists the fields returned and implies a read-only operation, but it does not explicitly state that it modifies nothing nor does it mention any permissions, side effects, or rate limits. The word 'List' suggests safety, but explicit confirmation 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?

Two concise sentences with no filler. The first states the tool's purpose and return content, while the second offers actionable usage guidance. 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?

With one parameter and no output schema, the description compensates by listing the specific attributes returned and providing a use case. It does not describe the exact response structure (e.g., list vs. map) or error behavior, but for a simple introspection tool, this is reasonably complete.

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

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

The only parameter 'model' has no schema description, and the description only says 'on an Odoo model.' It does not clarify the expected format (e.g., technical model name like 'res.partner') or whether it must be a string. The description adds minimal value beyond the parameter name.

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 immediately states 'List every field on an Odoo model' with a specific verb and resource. It enumerates the output attributes (type, label, required, readonly, relation target, selection options), clearly distinguishing it from sibling tools that search or create records.

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

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

The second sentence explicitly tells when to use the tool: 'Use this before create/write on an unfamiliar model instead of guessing field names.' This provides clear contextual guidance, though it does not explicitly mention when not to use it or name an alternative tool.

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

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

No annotations are present, so the description carries the full burden. It discloses behavior like 'Empty/omitted matches all records (subject to record rules)' and default limit of 80, which are meaningful. However, it does not mention offset behavior or return format, leaving some 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 compact and front-loaded, beginning with a clear one-line purpose followed by a concise parameter list. Every line provides useful information with no redundancy or 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?

Given the tool's generic nature and absence of output schema/annotations, the description covers essential aspects like domain semantics, limits, and ordering. It lacks a note about return value structure and offset, but the core usage is well covered for most scenarios.

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

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

Schema coverage is 0%, and the description compensates by explaining model, domain, fields, limit, and order with examples. It omits offset semantics, which is a minor gap, but overall it adds significant meaning beyond the schema's bare 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 states 'Search and read records of ANY Odoo model in one call' with a clear verb and resource scope. It differentiates from siblings by emphasizing generic model access, unlike specialized tools like search_invoices or search_budget_lines.

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 clarifies that it works for any model, implying use when a dedicated tool is absent, but does not explicitly exclude alternatives. It provides practical parameter guidance, such as 'limit 0 for no limit -- careful on large models', which helps agents decide when to use it.

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

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

With no annotations, the description carries the full burden. It discloses irreversibility ('CANNOT BE UNDONE'), the disabled-by-default behavior, the required environment variable to enable, and a specific behavioral contrast (accounting reversals). This is exceptional transparency for a destructive 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 concise and well-structured. The first sentence states the action and danger, the second explains why it's disabled, and the third gives the configuration. Every sentence serves a purpose, and it is front-loaded with the critical 'permanently delete' warning.

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

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

Given that this is a delete tool with no output schema, the description covers the essential context: irreversibility, opt-in activation, and a usage warning. It lacks details on return values or error handling, but those are less critical for deletion, and the safety/config context is fully addressed.

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 does not explicitly describe the 'model' or 'ids' parameters. It only implies that 'ids' refers to records being deleted, but provides no detail on what model names are valid or the type of IDs. With 0% schema coverage, the description fails to compensate 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 'Permanently delete one or more records' with a strong verb (delete) and explicit target (records). This distinguishes it from sibling tools like odoo_write (update) and odoo_create (create), 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?

It specifies that deletion is permanent and disabled by default, and contrasts with reversible accounting entries that should be reversed instead. This gives clear context for when to use the tool, though it doesn't name explicit alternative tools for deletion.

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 full responsibility for behavioral disclosure. It only states that updates existing records, but omits side effects (permanence), permissions, validation, or return behavior. This is thin for a mutation tool.

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

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

The description is a single, short sentence with no wasted words. However, it is under-specified; it earns its place as a brief summary but lacks structure or detail, making it minimally viable but not efficiently 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?

The tool is a generic write operation with three required parameters, nested objects, no output schema, and no annotations. The description only covers the basic action, failing to explain parameter semantics, return values, or usage constraints. This is inadequate for correct invocation in most scenarios.

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

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

Schema description coverage is 0%, and the description adds minimal value: it mentions 'field values' (relating to 'values') but does not explain 'model' or 'ids'. The agent must infer that 'ids' are record identifiers and 'model' is the target Odoo model, which is not explicitly stated.

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 updates existing records with field values, using a specific verb and resource. It distinguishes itself from odoo_create and odoo_unlink, though it doesn't explicitly position itself relative to specialized update tools like update_invoice.

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

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

No guidance is provided on when to use this tool versus alternatives. The description mentions no context, prerequisites, or exclusions, leaving the agent to infer usage from the generic 'update' verb.

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

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

With no annotations, the description carries the full burden. It discloses the critical behavioral trait that posting is irreversible and that a posted move must be reversed/credited rather than edited, which is valuable context beyond the action itself. It does not cover other side effects or preconditions, but the key risk is conveyed.

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 action, no wasted words. The irreversibility caveat is included efficiently.

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

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

The description explains the action and a key caveat, but fails to document the single parameter (move_id) and does not state the return value or prerequisites beyond 'draft' status. For a one-param tool with no annotations or output schema, this leaves important gaps.

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

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

The description does not mention move_id at all. With schema coverage at 0%, the description provides no compensation, leaving the agent to infer that move_id refers to the invoice/bill ID from the name and 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 verb 'Post (confirm)' and the resource 'draft invoice/vendor bill', which is specific and distinguishes it from sibling tools like create_invoice or post_journal_entry. It also notes irreversibility, reinforcing the action's purpose.

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

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

The phrase 'draft invoice/vendor bill' provides clear context for when to use this tool—when a draft invoice or vendor bill needs to be confirmed. However, it does not explicitly mention alternatives or exclusion criteria, so it lacks a formal when-not-to-use statement.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly states the irreversibility caveat and points to reversal as the correction method, which is the most critical behavioral trait for a posting operation. It doesn't cover other aspects like permissions or return values, but the key caveat is well addressed.

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, front-loaded with the primary purpose and followed by an essential caveat. Every word earns its place; there is no fluff or repetition of schema/annotation 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?

The tool is simple with one parameter, but the description fails to explain move_id and relies on prior knowledge of post_invoice for the caveat. The irreversibility warning is useful, but overall the description leaves gaps regarding the parameter and expected behavior, making it only partially complete.

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

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

The schema description coverage is 0%, and the description does not explain the move_id parameter. The agent must infer from the parameter name and tool context that move_id refers to the draft journal entry to be posted, which is not explicitly stated. This is a significant gap for the only required parameter.

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

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

The description clearly states the action: 'Post a draft journal entry.' It specifically identifies the resource (draft journal entry) and distinguishes it from sibling tools like create_journal_entry, update_journal_entry, and reverse_journal_entry by limiting to drafts. The reference to post_invoice also helps contextualize the action.

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 guidance: use this tool to post draft journal entries, and be aware of irreversibility. It also tells the agent what to do instead for corrections ('correct a posted entry with a reversal'), effectively offering an alternative approach and implying when not to use this tool. This is strong usage guidance.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It does disclose a meaningful filter ('from posted journal items only'), which is useful. However, it does not mention the read-only nature explicitly, nor what the report returns (e.g., totals, net profit), which would be important for an 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?

The description is a single, concise sentence that front-loads the essential purpose. It contains no filler words and is highly efficient.

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

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

With no output schema and no annotations, the description must explain what the tool returns. It specifies the data source (posted journal items) and account types (income/expense), but not the report structure or key output metrics (e.g., net income, totals). This leaves a significant gap for an agent interpreting the response.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only mentions 'date range' which maps to date_from and date_to, but does not explain the date format or the purpose of company_id. This is insufficient given the lack of 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 identifies the tool as a Profit & Loss (income statement) for a date range, specifying that it covers income and expense accounts from posted journal items. This distinguishes it from sibling report tools like balance_sheet or trial_balance by clearly defining its scope and data source.

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 an income statement report is needed, and the 'posted journal items only' note warns against using this for draft entry analysis. However, it does not explicitly compare to alternatives like balance_sheet or general_ledger, leaving some ambiguity about when to choose this over those tools.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It implies a mutating action ('reconcile') but does not describe side effects, error behavior when preconditions are violated, or whether it returns any output. For a mutation tool, this is a significant gap.

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

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

Two concise sentences with an example and a condition, containing no redundant information. 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 tool is simple with a single parameter, and the description covers the core action and key precondition. However, with no output schema and no annotations, it omits return behavior, failure modes, and potential interaction with sibling tools like search_unreconciled_lines, leaving the description slightly incomplete.

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

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

Schema description coverage is 0%, and the description only clarifies that line_ids are 'account.move.line ids'. It adds minimal value beyond the parameter name, omitting item type, format, or any constraints beyond the partner/account requirement. With only one parameter, the low coverage is not fully compensated.

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

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

The description uses a specific verb ('Reconcile') and resource ('account.move.line ids'), with a concrete example ('a payment line against an invoice line'). It clearly distinguishes from siblings like search_unreconciled_lines, which only search for lines rather than reconcile them.

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

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

It provides clear context for when to use the tool (reconciling lines) and states a key precondition (same partner and reconcilable account). However, it does not explicitly name alternatives or when not to use it, so it lacks explicit exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses a key behavioral trait—'keeps reconciliation correct'—and warns against direct writes, which is valuable. However, it omits other behavioral details such as whether the payment is automatically posted, how partial payments are handled, or what side effects occur on the invoice. The description is not misleading but incomplete.

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

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

The description is a single, dense sentence that front-loads the action and includes a crucial warning. Every part adds value—no fluff or repetition. It is concise while conveying the essential information.

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

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

The tool has 5 parameters, no output schema, and no annotations, so the description should explain return behavior and parameter meanings. It only partially explains move_id and implies a successful registration, but does not state what is returned (e.g., payment ID) or any post-conditions. This is inadequate for a financial operation with this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints that move_id relates to 'a posted invoice/bill', but provides no meaning for amount, journal_id, payment_date, or payment_method_line_id. This leaves most parameters unexplained, making it hard for an agent to know what values to supply.

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

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

The description uses a specific verb+resource ('Register a payment against a posted invoice/bill') and distinguishes itself from direct write operations by warning 'never write account.payment directly'. This clearly identifies the tool's function and separates it from sibling tools like create_invoice or reconcile_lines.

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 instructs to use this tool via Odoo's standard account.payment.register wizard model and states 'never write account.payment directly', providing an explicit exclusion of an alternative approach. This gives clear guidance on when to use this tool versus a direct write.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It conveys that the tool is non-destructive to the original entry (creates a reversal rather than editing/deleting) and that it only operates on posted moves. However, it does not disclose potential side effects, error conditions, or the state of the original entry after the reversal.

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

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

The description is a single sentence that front-loads the action and the key rule. It is concise, direct, and contains no unnecessary 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?

The description covers the core purpose and usage guidance clearly, but given the lack of annotations, output schema, and low schema description coverage, it leaves gaps around parameter semantics and the result of the reversal. It is adequate for a straightforward operation but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It only indirectly references move_id as the target move to reverse, but it does not explain the date or reason parameters, their formats, or whether they are optional. This leaves significant ambiguity for a tool with three 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 clearly states the tool's function: creating and posting a reversal of an already-posted move. It distinguishes itself from editing or deleting by framing this as 'the correct way to undo a posted entry,' which sets it apart from sibling tools like update_journal_entry and odoo_unlink.

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 states when to use this tool: to undo a posted entry. It also provides a clear 'never' instruction against editing or deleting a posted move directly, implying when not to use alternative operations. This is explicit usage guidance with exclusions.

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

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

With no annotations provided, the description carries a high burden. It offers a useful domain example, but it does not disclose read-only behavior, return format, pagination, or any side effects. The example adds some behavioral context but leaves important details unstated.

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, with two clear sentences: the first states the tool's purpose, and the second provides a concrete domain example. Every word earns its place, with no redundancy.

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

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

The tool has two parameters and no output schema, so the description should cover the return format, default behavior, and edge cases. It covers the domain parameter well, but it does not describe what the tool returns or how the limit parameter affects results. This leaves gaps for a complete understanding.

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

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

The schema has no descriptions for the two parameters (coverage 0%), so the description must compensate. The example domain clarifies the structure of the domain parameter as a list of [field, operator, value] triples, which is valuable. However, the limit parameter is not explained beyond its schema default, so it partially compensates.

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

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

The description clearly states a specific verb+resource: 'Search BOQ lines across any budget/project.' It distinguishes from sibling tools like search_invoices and search_journal_entries by targeting BOQ lines specifically. The example domain reinforces the purpose.

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

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

The description provides clear context on what the tool does (searches BOQ lines across budgets/projects) and gives a domain example, implying when to use it. However, it does not explicitly mention alternatives or when not to use it, so it falls 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?

With no annotations, the description must convey behavior, but it only says 'Search' and provides a domain example. It does not disclose return format, pagination, default limit behavior, or any constraints such as read-only or required permissions, so the agent lacks critical behavioral context.

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

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

The description is short and front-loaded, with the core purpose in the first sentence and the example domain in the second. It is efficient and contains no filler, though the example could be integrated more formally.

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 only two parameters and no output schema, the tool's search functionality warrants more context—such as what records are returned, how pagination works, and when to prefer this over similar search tools. The description is too sparse to fully support correct invocation.

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

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

The input schema has no field descriptions and 0% schema coverage, so the description must compensate. The example domain adds some meaning to the 'domain' parameter by showing the list-of-lists structure with fields like 'move_type' and 'state', but it does not explain 'limit' or other domain syntax variations.

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 ('Search') and targets a defined resource set ('customer invoices / vendor bills / credit notes'), which is clear and goes beyond the tool name. It partially distinguishes from siblings like search_journal_entries by listing specific move types, but it does not explicitly name alternatives or edge cases.

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 explicit guidance is given about when to use this tool versus alternatives such as search_journal_entries or get_invoice. The example domain shows how to filter, but it does not explain selection criteria or exclusions, leaving usage context entirely implied.

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

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

With no annotations, the description carries the full burden. It provides a useful domain example that reveals the expected filter syntax and scope, but it does not disclose return format, default limit behavior, or whether the search returns results when domain is null. This is moderate transparency for a read-oriented search tool.

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

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

The description is two sentences and directly to the point. It includes a compact, illustrative example that earns its place by clarifying domain syntax without unnecessary verbosity.

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

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

For a simple search tool with two parameters and no output schema, the description covers the core search scope and provides an example. However, it omits usage context, limit semantics, and return output details, 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 0%, and the description adds meaning only for the 'domain' parameter via the concrete example. The 'limit' parameter is not explained, leaving a gap. The example is helpful but only partially compensates for the complete lack of parameter descriptions in the schema.

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

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

The description identifies the tool as searching journal entries, invoices, and bills across any move_type, giving a clear verb and resource. It is specific enough to distinguish from generic search tools, though it does not explicitly contrast with sibling tools like search_invoices.

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

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

No guidance is provided on when to use this tool versus alternatives such as search_invoices or odoo_search_read. The example domain shows how to query, but there is no explicit context for choosing this tool 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?

With no annotations, the description carries the burden of behavioral disclosure. It does reveal the key filter (only open/unreconciled lines), but does not describe pagination behavior, return format, or potential side effects, leaving gaps for an 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?

The description is a single, focused sentence that is front-loaded with the action and subject. Every word contributes to the meaning, making it easy to parse and remember.

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 conveys the core purpose but omits information about return values and how parameters affect filtering. With no output schema and no annotations, the agent lacks some context needed for correct invocation, especially regarding what the tool returns.

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

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

Schema coverage is 0%, and the description does not mention any of the three parameters (limit, account_id, partner_id). While parameter names are self-explanatory to some extent, the description adds no semantic value and fails to compensate for the lack of parameter 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 the tool finds open (unreconciled) receivable/payable move lines, with a concrete example ('to match a payment to its invoice'). This specific verb and resource distinguish it from sibling tools like search_invoices (invoices vs move lines) and search_budget_lines.

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 example provides a clear use case for reconciliation scenarios. However, it does not explicitly mention when not to use this tool or name alternatives, so the guidance is implicit rather than comprehensive.

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

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

With no annotations provided, the description must communicate behavioral traits. It only states the state transition ('Move a draft budget to Submitted') without disclosing side effects, permissions, reversibility, or error conditions. For instance, it does not mention what happens if the budget is not in draft state or whether the action can be undone. This lack of behavioral context is a significant gap for a mutation tool.

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

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

The description is a single, concise sentence: 'Move a draft budget to Submitted (action_submit).' It contains no filler and front-loads the core action clearly.

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's simplicity (one parameter, no output schema, no annotations), the description still leaves gaps. It does not explain the budget lifecycle context, such as prerequisites (draft status), consequences of submission, or how it differs from approval/activation. The lack of any behavioral or workflow context makes it incomplete for an agent that needs to decide and invoke this tool reliably.

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

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

The schema has 0% description coverage for the sole parameter 'budget_id'. The description does not explicitly mention the parameter, though 'a draft budget' implies the identifier. However, it does not explain any constraints, such as the budget needing to be in draft status, or the format of the ID. Since the parameter is self-evident, it gets a small credit, but the description fails to compensate for the lack of schema documentation.

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 function: 'Move a draft budget to Submitted (action_submit)'. It uses a specific verb ('Move'), identifies the resource ('draft budget'), and specifies the target state ('Submitted'), which distinguishes it from sibling tools like 'approve_budget' and 'activate_budget'.

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: it should be used when a budget is in draft state and needs to be submitted. However, it does not explicitly mention when not to use it or provide alternatives such as 'approve_budget' or 'activate_budget'. The context of sibling tools suggests a workflow, but this is not articulated in the 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. It does disclose the output structure (opening + period debit/credit + closing per account), which is useful, but it omits behavioral details such as read-only status, date handling, company scope, or error behavior. The description is acceptable 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 concise sentence that front-loads the tool's purpose and output structure. Every word contributes meaning; there is no redundancy 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 a report tool with no annotations, no output schema, and 0% schema description coverage, the description is too sparse. It lacks parameter semantics, usage context, and behavioral expectations, making it insufficient for an agent to invoke it confidently in all scenarios.

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

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

Schema description coverage is 0%, so the description must compensate. It only implies that date_from/date_to define the period, but it does not explain the date format, the meaning of company_id, or any constraints. This is minimal compensation for the missing parameter 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 identifies the tool as a trial balance report and specifies its composition: opening balance, period debit/credit, closing balance per account for a period. This distinguishes it from other accounting reports like general_ledger, though it does not explicitly name alternatives.

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

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

No guidance is provided on when to use this tool versus sibling reports such as general_ledger or profit_and_loss. The phrase 'for a period' implies a date range, but there is no explicit context, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses that computed fields like 'auto_etc' and 'effective_etc' are always derived by Odoo and attempts to write them will be ignored or rejected, plus explains the correct way to move the forecast via 'etc_mode' and 'manual_etc'. This is valuable behavioral context 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?

The description is concise and well-structured. It leads with the action, lists the supported fields, and then provides a crucial warning with a clear alternative. Every sentence earns its place without unnecessary verbosity.

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

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

For a mutation tool with no annotations and a free-form parameters object, the description is remarkably complete. It covers the full range of updatable fields, explicitly warns against computed fields, and gives the correct pattern for adjusting the forecast. No critical gaps remain.

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 only defines 'line_id' and a free-form 'values' object (0% coverage). The description compensates fully by enumerating the allowed keys within 'values' and explaining the semantics of 'etc_mode' and 'manual_etc', which is essential for correct use.

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 purpose: 'Update any field(s) on a BOQ line' and lists the specific fields it can modify. This distinguishes it from sibling tools like generic 'odoo_write' by focusing on BOQ lines specifically.

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 clear context on how to use the tool, including which fields are safe to write and a strong 'never write' instruction for computed fields. It doesn't explicitly mention alternative tools, but the behavioral exclusions (e.g., 'Never write auto_etc...') serve as important when-not guidance.

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

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

No annotations are present, so the description carries full behavioral burden. It discloses the destructive line-replacement behavior ('lines, if given, REPLACES all existing lines') and the posted-document rejection. However, it does not mention whether 'values' merges or overwrites header fields, nor does it describe return values or permissions, which slightly reduces 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 sentences with zero waste. The first sentence states purpose, the second gives a critical exclusion, and the third details the destructive lines behavior. Information is front-loaded and each 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?

Given the tool's complexity (nested objects, no output schema, no annotations), the description covers the main functionality and key caveats. It leaves minor gaps such as the exact behavior of 'values' (merge vs replace) and response format, but the critical info for safe usage is present. The reference to create_invoice helps with line-dict shape.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'lines' thoroughly (replaces all existing lines, same shape as create_invoice) and implies 'values' is for header fields from the opening sentence. 'move_id' is self-evident. Lacks explicit detail on the 'values' object structure, but coverage is strong overall.

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 'Update' with a clear resource ('draft invoice/bill') and scope ('header fields and/or replace its lines entirely'). It distinguishes itself from siblings like post_invoice and create_invoice by explicitly stating draft-only status and the line replacement behavior.

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: 'Odoo will reject this once the move is posted -- use a reversal/credit note for posted documents instead.' This clearly states when NOT to use the tool and names an alternative for posted documents. Also references create_invoice's lines argument for shape consistency.

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

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

No annotations are provided, so the description carries the burden. It discloses that lines are replaced entirely (a destructive behavior) and that the entry must be a draft, but it does not mention permissions, reversibility, what happens to existing lines if omitted, or behavior on non-draft entries.

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 action, with no redundant wording. The reference to create_journal_entry's `lines` shape is efficient and concise.

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

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

Given complex update semantics, no annotations, and no output schema, the description covers the main purpose and reusable shape but omits important details like how values are applied, whether lines are optional, error states, and side effects. It is minimally adequate but not thorough.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the `lines` parameter by referencing create_journal_entry's shape, and implies `values` are header fields, but `move_id` is left unexplained. The description adds some meaning but not enough for all 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 clearly states the action ('Update') and the resource ('a draft journal entry'), and specifies the two aspects: header and/or lines. It distinguishes from siblings like 'create_journal_entry' and 'post_journal_entry' by focusing on updating a draft.

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 for modifying draft journal entries, as opposed to creating, posting, or reversing them. It provides clear context but does not explicitly name alternatives or state when not to use this tool.

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