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

With no annotations, the description carries full behavioral burden. It discloses composition of approved leaves, pending requests, headcount, the coverage-threshold formula, and timezone handling, making the read-only reporting behavior clear. It could explicitly state 'does not modify data', but the 'Report' framing and algorithm details provide strong transparency.

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

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

The description is compact and well-organized: a title line, a synthesizing body, and an Args section. Every sentence earns its place with no filler.

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

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

Given an output schema is present and all parameters are optional with defaults, the description is complete for invocation. It explains what the tool returns (calendar, risk flags, verdict), parameter semantics, and the underlying data sources.

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?

Input schema provides names and defaults but zero descriptions. The description compensates fully: days as look-ahead window, coverage_threshold as department-share threshold, and timezone_offset as UTC offset for 'today'. This adds high-value meaning beyond the schema.

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

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

The description begins with 'Report who is off and where coverage is thin', a specific verb+resource+outcome. It clearly distinguishes itself from siblings by focusing on absence/coverage, and details the exact sources and outputs (calendar, flags, verdict).

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 positions itself as a one-call composite for absence and coverage needs, explaining what it combines. It does not explicitly name alternatives or exclusions, but the intended use case is clear and no sibling tool covers absences.

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, description carries full burden. It explains aggregation behavior, available aggregators, default actions (e.g., omit measures to count records), and a cap on limit. Does not explicitly state read-only nature, but server-side aggregation implies no mutation.

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

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

Description is front-loaded with purpose, followed by a clear list of parameters. Every sentence is informative, no fluff or repetition. Efficient and well-structured.

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

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

Covers all input parameters including optional ones, provides examples, and mentions system limits (ODOO_MAX_RECORDS). Output schema exists, so return format is not needed in description. Complete for a complex tool with 7 parameters.

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

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

Schema coverage is 0%, so description fully explains all 7 parameters. Provides syntax examples (e.g., 'date_order:month'), allowed aggregators, defaults, and usage notes. This compensates for missing schema descriptions and adds significant value.

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?

Clearly states 'Group and aggregate records server-side', which is a specific verb-resource combination. Distinguishes itself from raw data retrieval tools like read_records or search_read by emphasizing server-side aggregation.

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 context for use ('one call instead of pulling rows') and detailed parameter explanations, but lacks explicit 'when not to use' or direct comparison to sibling tools. However, the description is sufficient for an informed choice.

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. The description discloses sections are independent and handle unavailable apps gracefully, but does not detail mutability, auth requirements, or rate limits. Some behavioral context is added but not comprehensive.

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 a one-line summary followed by details. No wasted sentences. Front-loaded and to the point.

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 an output schema exists, the description adequately covers functionality, parameters, and edge cases (unavailable apps). No gaps for a briefing 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?

With 0% schema description coverage, the description adds meaning for both parameters: timezone_offset default and purpose, company optionality and scope. This significantly aids the agent.

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 it is a one-call company briefing covering sales, leads, receivables, tasks, absences, distinguishing it from sibling tools like sales_snapshot or receivables_health which focus on single aspects.

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 as a morning standup view but does not explicitly state when to use versus alternatives or when not to use. No exclusions 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 behavioral traits. It only states it confirms a quotation, implying mutation but does not mention side effects, permissions, irreversibility, or post-conditions. The 'action_confirm' hint is present but insufficient.

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 waste. However, it could slightly expand to cover key behavioral aspects without damaging 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 only 2 parameters, no annotations, but an output schema exists, the description fails to explain the confirm parameter's role, the output structure, or any side effects. It is too brief to be fully useful for an agent.

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 'quotation' but does not explain what 'order_id' refers to or how the boolean 'confirm' affects behavior. The description adds minimal meaning beyond parameter 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 clearly states the verb 'confirm' and the resource transformation from 'quotation' to 'sales order', with a precise Odoo model reference (sale.order action_confirm). This specificity distinguishes it from sibling tools, which are mostly generic CRUD or different analytical 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 provides no guidance on when to use this tool versus alternatives. It does not explain prerequisites, typical scenarios, or when not to use it, leaving the agent without decision context.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses the preview/mutation dual behavior via the confirm parameter and the ability to set unmodeled fields via extra_values. It does not detail permissions, error handling, side effects, or what happens on success/failure beyond creation.

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

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

The description is short (two sentences) with the first sentence front-loading purpose and key behavior. It is efficient, though the second sentence could be more specific about extra_values usage.

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 presence of an output schema (not shown), return values may be covered there. However, the description lacks details on behavior when confirm=False vs True, required fields beyond name, validation, and error scenarios. It is minimally adequate for creating a contact.

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 meaning to the confirm parameter (preview vs actual) and extra_values (fields not modeled), but does not describe email, phone, parent_id, is_company, or the format of extra_values. For 7 parameters, this is insufficient.

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 it creates a contact (res.partner) and mentions preview behavior. It differentiates from generic create_record by specifying the model, but does not explicitly contrast with siblings like create_lead or create_task.

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 that the tool can be used for preview (confirm=False) or immediate creation (confirm=True), and for setting extra fields via extra_values. However, it does not provide guidance on when to use this tool versus alternatives like create_lead or create_record, nor does it mention prerequisites or conditions.

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?

Since there are no annotations, the description carries the burden of behavioral disclosure. It importantly discloses the preview behavior ('Preview unless confirm=True') and explains the role of extra_values for setting fields not modeled by the helper. It does not however describe side effects, permissions, or error handling, so a 4 is appropriate.

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. The second sentence provides key behavioral details without unnecessary verbosity. 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?

The description covers the essential purpose, preview mode, and extra_values handling, and an output schema exists for return values. It could benefit from a brief note on whether the tool requires authentication or how preview results are returned, but overall it is reasonably complete for a create tool with 7 parameters.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for two non-obvious parameters: confirm (preview vs actual create) and extra_values (custom fields and mandatory fields). Other parameters like name, email, and phone are self-explanatory from their names and types.

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

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

The description clearly states 'Create a CRM lead/opportunity (crm.lead)', using a specific verb and resource. It distinguishes itself from sibling tools like create_contact or create_task by specifying the crm.lead model.

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 that this tool is for creating CRM leads/opportunities, but does not explicitly mention when not to use it or alternatives like create_contact. The guidance on using extra_values hints at how to handle custom fields, but lacks explicit exclusion criteria.

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 takes full responsibility. It discloses that the tool can either preview or actually create based on confirm, and that the model must be writable. This provides clear behavioral expectations, though it could explicitly state that it performs write operations.

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

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

The description is extremely concise: two sentences plus a bulleted list of parameters. Every sentence adds value, and the structure (overview then args) is clear.

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

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

Given the complexity (3 params, no annotations, but output schema exists), the description covers the core behavior: creation with preview option, model constraints, and parameter details. It doesn't describe the return format of preview, but the output schema (unseen) likely covers that.

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 adds meaning: model must be in ODOO_WRITABLE_MODELS, values is a field-value mapping, and confirm toggles between preview and actual creation. This is far beyond the schema's basic type definitions.

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

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

The description clearly states 'Create one record' and explains the preview versus actual creation via confirm parameter. It distinguishes itself from sibling tools like create_contact or create_lead by being generic, covering any Odoo model.

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

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

The description implies usage for creating any record in ODOO_WRITABLE_MODELS and mentions a dry-run mode, but does not explicitly compare with siblings or state when not to use this tool versus specific creators like create_contact.

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

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

No annotations exist, so the description carries full burden. It discloses that the tool previews creation by default and requires confirm=True to actually create. This is a key behavioral trait for a write operation.

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

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

The description is two sentences plus a brief instruction. It is efficient, front-loaded with the primary action, and every sentence adds value. No wasted words.

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

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

Given that an output schema exists, return values need not be explained. The description covers the core behavior, prerequisite, and advanced use with extra_values. However, it omits details on optional parameters like user_id and deadline, which are intuitive but could be clarified.

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 confirm parameter's effect and extra_values as a catch-all. But it does not describe user_id, description, or date_deadline, which are covered only by schema titles.

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 specifies the tool creates a project task (project.task) and distinguishes it from sibling tools like create_record by being task-specific. The verb 'Create' is clear and the resource is explicitly named.

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 a prerequisite: use list_projects to find project_id. It also advises using extra_values for unmodeled fields. However, it does not explicitly state when to avoid using this tool (e.g., for other record types), but the context makes it adequate.

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

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

With no annotations, the description discloses destructive nature, server requirement, and dry-run mode. This covers key behavioral traits adequately.

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?

Description is concise with a clear bullet list for args. Front-loaded main behavior. Slightly more structured formatting could improve, but it's effective.

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 3 params, no annotations, and output schema, the description covers purpose, behavior, prerequisites, and parameter details completely.

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 0% coverage, but description explains all three parameters: model (with constraint), ids (what they are), confirm (dry-run vs actual delete). Adds full meaning.

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

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

The description clearly states the tool deletes records with a dry-run option. It distinguishes from siblings like create_record and read_records by specifying destructive action and preview 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?

It provides prerequisites (ODOO_ALLOW_DELETE flag, model must be in writable models) and explains confirm parameter for dry-run. However, it does not explicitly compare to alternatives or state when not to use.

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. 'Inspect' signals a read-only, non-destructive operation, and the description explicitly lists the returned field attributes. It does not mention errors, permissions, or rate limits, but for a schema inspection tool, this is sufficient behavioral disclosure.

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

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

Three sentences, front-loaded with the core purpose, no fluff. The example is valuable and the filtering instruction is directly actionable. 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 has an output schema, but the description already explains what is returned (field attributes) and how to constrain the result. With only 2 parameters and a clear example, the description is sufficiently complete for an agent to choose and invoke the tool correctly. Minor gaps like optional parameter behavior are covered by schema defaults.

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 `fields` parameter ('limit the result to specific field names') and provides a concrete example value for `model` ('res.partner'). This adds meaning beyond the bare schema definitions, though it does not formally define the model parameter's semantics or the array format for 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 a specific verb and resource: 'Inspect the schema of an Odoo model.' It also enumerates what is returned (label, type, help text, requiredness, relation), which distinguishes it from sibling tools like read_records (data) or list_models (model names).

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 for when to use this tool: when you need schema/field information. It gives an example model, but does not explicitly mention alternatives or exclusions. Sibling tools like search_read or read_records are not referenced, but the purpose is unambiguous enough.

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

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

No annotations are provided, so the description carries the full burden. It discloses the bounded heuristic for dead-stock detection (200-group cap), which adds transparency about a limitation. It also explains the definitions of shortages and dead stock clearly.

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: a brief introductory sentence, then a clear Args section. Every sentence adds value, and there is no redundancy or wasted words.

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

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

Given the tool has an output schema, the description does not need to explain return values. It covers the purpose, the two risk types, the bounded heuristic, and all parameters. Contextually complete for a risk-reporting 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 coverage is 0%, so the description must compensate. It explains all four parameters (dead_stock_days, top_n, timezone_offset, company) with defaults and behavioral context, such as company scoping. This adds significant meaning beyond the schema.

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

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

The description clearly states 'Report stock at risk — shortages and dead stock — in one call.' It uses a specific verb (report) and resource (stock at risk), and distinguishes from sibling tools like absence_overview or business_pulse by specifying the exact risk categories.

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

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

The description implies usage for inventory risk assessment by explaining shortages and dead stock, but it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or when-not-to-use scenarios.

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 only states the listing action without describing any side effects, permissions, or constraints (e.g., it is read-only, no destructive potential). The description lacks transparency about the tool's behavior beyond the basic action.

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

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

The description is two sentences with no redundancy. The main action is front-loaded, and the optional filtering is explained concisely with examples. 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?

Given the simple parameter set and the presence of an output schema, the description is complete. It covers the tool's purpose, filtering, and examples. No missing information is evident.

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 sole parameter 'name_filter' is described in detail: a case-insensitive substring filter against model name or label, with concrete examples. Since schema coverage is 0%, the description fully compensates by adding meaning beyond the schema, which only defines type and default.

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 it lists Odoo models (technical name + label) with optional filtering. The verb 'list' plus the specific resource 'Odoo models' makes the purpose unambiguous, and it distinguishes from sibling tools that deal with records or other entities.

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 explains the optional filter with examples, which implies usage, but does not explicitly state when to use this tool versus alternatives like search_read or read_records. No when-not-to-use or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It communicates that the tool checks connectivity and returns version info, which implies a read-only operation and no side effects. However, it does not explicitly state that it is non-mutating or describe any edge cases (e.g., network failures), so transparency is adequate but minimal.

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

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

The description is a single, clear sentence that covers both the action and the expected result with no waste. It is perfectly front-loaded 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 the tool's simplicity (no parameters) and the existence of an output schema, the description adequately explains the tool's purpose without needing to detail return format. It could theoretically mention that it is safe to call at any time, but that is not a significant gap for such a straightforward 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?

The tool has zero parameters, so the schema is complete and there is nothing to add. Per the baseline rule, a score of 4 is appropriate when there are no parameters, and the description adds no unnecessary parameter explanations.

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 ('Check connectivity') and a specific resource ('Odoo server version info'), making the tool's purpose unambiguous. It naturally distinguishes itself from sibling tools like read_records or create_record, which are CRUD operations, whereas this is a version/connectivity check.

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

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

There is no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description simply states the function without contextual usage cues. Given the wide variety of sibling tools, this lack of usage guidance leaves the agent to infer appropriateness.

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 does this well by detailing what the tool computes: open opportunities are composed into totals, stalled deals are defined by 'no stage change in stalled_days', and a rule-based verdict is generated with configurable thresholds. It stops short of explicitly stating read-only behavior or error handling, but the term 'Report' and the output-oriented language make the non-mutating nature 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 front-loaded with a one-sentence summary, followed by a compact list of computed metrics and then the Args list. Every sentence contributes necessary information, with no fluff or repetition. The structured layout makes it easy to scan while remaining concise given the large number of parameters.

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

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

The description covers the tool's purpose, all computed metrics, parameter meanings, and the logic behind the verdict thresholds. An output schema exists, so return-value details are not needed. The only gap is the absence of explicit usage scenarios or alternative tool comparisons, but overall this is a complete and self-contained description for a complex reporting 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?

The schema provides only names and defaults, but the description includes an Args section with plain-language explanations for all 10 parameters. For example, 'stalled_days: Days without a stage change before a deal counts as stalled' and 'timezone_offset: UTC offset for today' add meaning far beyond the schema. This fully compensates for the 0% schema description coverage.

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

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

The description opens with a clear and specific statement: 'Report the health of the CRM pipeline, in one call.' It then enumerates the exact metrics and breakdowns computed (totals, stalled deals, close-date buckets, per-stage/per-salesperson breakdowns, win rate, verdict), making the tool's scope unmistakable. This distinguishes it from sibling tools that focus on raw record access or single-aspect reports.

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 'in one call' implies the tool is intended for a consolidated health snapshot, and the detailed metric list suggests when to use it. However, it does not explicitly contrast with sibling tools (e.g., sales_snapshot, team_workload) or state when not to use it. Thus, usage guidance is implied but not made explicit with alternatives 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?

No annotations provided, so description must carry full burden. It explains that the tool returns raw signals and the client computes health scores, and notes the server-side join behavior. However, it does not explicitly state that the tool is read-only or disclose any potential side effects or permissions needed.

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?

Description is concise: a single-line summary followed by context and a well-structured parameter list. Every sentence adds value 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?

Given the presence of an output schema, the description adequately covers the tool's behavior and parameters. It explains the return type (raw signals) and the filtering options. Minor missing details about pagination or error cases, but overall complete for its complexity.

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

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

Schema coverage is 0% but the description provides meaningful explanations for all 6 parameters, including the ilike search behavior for manager and customer, defaults, and the purpose of lookahead_days and timezone_offset. Adds value beyond the schema's name and type.

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

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

Description clearly states it provides a portfolio overview with one row per project, joined server-side. Distinguishes itself from the project_status_report and project_profitability tools it replaces. Purpose is 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?

Explicitly mentions it replaces the project_status_report and project_profitability pair, giving context on when to use it instead. Provides rationale (avoiding duplicate name issues) but does not include explicit when-not-to-use scenarios.

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

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

The description lists what the report composes (open value, late receipts, per-vendor spend, stale RFQs, rule-based verdict), which provides behavioral context. However, since no annotations are provided, it does not explicitly state that it is read-only or disclose any side effects, but the composition details are sufficient for an agent to understand the output.

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 well-structured with a clear summary, composition details, and an Args section. It is efficient but slightly verbose; could be trimmed slightly while retaining clarity.

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

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

Given the complexity of the tool (5 parameters, no annotations, output schema exists), the description provides a thorough overview of what the report includes. It adequately covers the return structure without needing to detail output format since an output schema exists.

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

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

With 0% schema description coverage, the description compensates well by explaining each parameter's purpose and default values in the Args section (e.g., late_grace_days, rfq_stale_days, top_n, timezone_offset, company). This adds meaning beyond the schema.

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

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

The description clearly states it is a 'Report purchasing health — late receipts and stale RFQs — in one call.' This specific verb+resource combination distinguishes it from sibling health reports like inventory_risk or production_health.

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

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

The description implies usage for a consolidated purchasing health check but does not explicitly state when to use this tool versus alternatives or provide any exclusions. No guidance on when not to use it.

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

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

With no annotations provided, the description carries the full burden. It discloses the underlying logic (composing orders by state, identifying late starts and stuck orders, rule-based verdict) and parameter semantics. It does not explicitly state that it is read-only, but 'Report' implies no mutation. The description reveals enough behavioral detail to set expectations.

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 well-structured and front-loaded with a clear summary. It uses a concise paragraph followed by a labeled Args list. Every sentence earns its place, with no wasted words.

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

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

Given the tool's moderate complexity and the presence of an output schema, the description is complete. It explains inputs, logic, and scope, and does not need to describe return values. The lack of annotations is compensated by the detailed description.

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

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

The input schema provides only types and defaults with no descriptions (0% coverage). The description compensates fully by explaining each parameter in the Args section: stuck_days, top_n, timezone_offset, and company. This adds significant meaning beyond the schema.

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

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

The description clearly states the tool's purpose with a specific verb ('Report') and resource ('manufacturing health'), and distinguishes it from sibling tools by focusing on late starts and stuck orders in production. The phrase 'in one call' highlights its consolidated nature, making it distinct from other report 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 clearly implies when to use this tool — when a comprehensive manufacturing health report is needed. It provides context about the type of data and metrics included. However, it does not explicitly mention exclusions or alternatives, 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 fully discloses behavior: it reads from Budgets app, uses specific matching logic, computes absolute amounts, compares with analytic costs, and flags uncovered spend. It clarifies why no date filters exist.

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

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

The description is efficiently structured: first paragraph for overall behavior, second for internal details, then clear parameter list. Every sentence adds value without redundancy.

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

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

Given the complexity (7 params, output schema exists), the description covers all necessary context: inputs, behavior, special cases, and what the output represents. No gaps identified.

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 carries all parameter explanations. The Args section explains each parameter with defaults and behavior (e.g., project filter triggers per-line breakdown, default values given).

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 planned vs actual budget per project, line by line. It distinguishes itself from sibling tools like project_dashboard or project_status_report by focusing on budget comparisons.

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

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

The description implies usage for budget analysis with filters, and explains the behavior when a single project is matched. However, it does not explicitly compare to siblings or mention when not to use.

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

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

No annotations provided, but the description discloses critical behaviors: sections fail soft (errors returned without breaking the call), budget_ids null vs [] distinction, default values for lookahead_days and timezone_offset.

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?

Well-organized with context, usage tips, soft-fail note, and parameter list. Efficient overall, though a few minor wordings could be tightened.

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

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

Covers all necessary aspects: purpose, parameter semantics, default behavior, and error handling. Output schema exists, so return value documentation is unnecessary.

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

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

With 0% schema coverage, the description fully explains every parameter: project_id, include, budget_ids, filter flags, and defaults. Adds meaning beyond schema types (e.g., budget_ids omits vs []) and clarifies interactions.

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?

Clearly states that the tool aggregates all project dashboard data into one call, replacing ~12 separate calls. The verb (fetch/retrieve) is implied, and the resource is well-defined.

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 specific guidance on using the 'include' parameter to re-fetch only changed sections, and explains the nuanced behavior of budget_ids. Does not explicitly contrast with sibling tools like project_budget.

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

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

With no annotations, the description carries the full burden and excels: it discloses the composition of active project records, timesheet hours, analytic cost/revenue, and Budgets app dependency. It also reveals that date filters disable burn verdicts and that single-project matches trigger drill-downs.

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

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

The description is front-loaded with a one-sentence summary, followed by a compact explanation of data composition, and then a well-organized parameter list. No filler, every sentence 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?

Given the tool's complexity (9 params, no annotations), the description is remarkably complete. It covers purpose, data sources, filtering behavior, edge cases (date filters, single-match), and parameter details. The existence of an output schema reduces the need to describe return values, but it still explains the burn verdict logic.

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%, but the Args section provides rich, explicit semantics for all 9 parameters—including ilike filters, default behaviors, and the date-filter caveat. This compensates fully for the schema's lack of 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 opens with a specific verb+resource: 'Report delivery hours, money and budget burn per project in one call.' It clearly distinguishes this from siblings like project_dashboard or project_status_report by focusing on profitability and burn verdicts.

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 conveys clear context for use—when you need a consolidated per-project profitability report with burn status—but does not explicitly mention when not to use it or compare it to alternatives. The data sources and filters imply appropriate scenarios.

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 and explains the derivation process (milestones, health verdict, divergence flag, risk ranking). It does not disclose auth needs or rate limits but sufficiently details the computational behavior.

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 well-structured with a clear summary followed by details and parameter list. It is slightly verbose but each sentence adds value; minor improvements could tighten phrasing.

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

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

Given the tool's complexity (7 params, derived health logic) and presence of an output schema, the description covers core behavior comprehensively. It does not mention pagination or ordering but is otherwise 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 description adds substantial meaning beyond the schema for all 7 parameters, including filtering semantics (ilike), default values, and purpose. Despite 0% schema description coverage, the description fully 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 the tool reports which projects are in trouble across a portfolio, deriving health verdicts. This is specific and distinct from sibling tools like business_pulse or inventory_risk, which cover different domains.

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 parameter filters but does not explicitly guide when to use this tool versus alternatives like 'pipeline_review' or 'sprint_health'. No 'when not to use' or comparison is given, leaving some ambiguity for the agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does an excellent job by disclosing nuanced behaviors such as 'Cancelled tasks DO count toward delivery hours (business decision 2026-07-15)' and that periods are 'OR-combined (matching per-budget-period filtering, not a union)'. However, it does not mention potential edge cases like error handling for invalid project_id, which would make it fully transparent.

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

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

The description is front-loaded with a one-sentence summary, then provides usage guidance and a structured Args list. Every sentence earns its place, and the length is justified given the 7 parameters. No fluff or repetition.

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

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

Given the tool's complexity (7 parameters), lack of annotations, and presence of an output schema, the description is remarkably complete. It covers all parameter semantics, usage context, and important edge cases like the OR-combining of periods and the 'no_date_end' bucket, leaving no significant 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%, so the description must compensate, and it does thoroughly. The 'Args' section explains every parameter in plain language, including types, defaults, and subtle semantics (e.g., 'tasks without date_end are excluded from the buckets and summarised under "no_date_end"'). This goes far beyond the bare schema.

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

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

The description uses a specific verb ('sums') and resource ('total sub-task hours for one project'), and explicitly differentiates itself from the sibling tool search_read by saying 'use this instead of paginating project.task through search_read'. This makes the tool's purpose unmistakable.

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 instead of alternatives: 'Use this instead of paginating project.task through search_read — especially for the "exactly one assignee" condition, which Odoo domains cannot express.' It also notes the server-side filtering and single-call behavior, providing clear 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 bears full burden. It clearly discloses behavior: metadata always returned, base64 content if under size limit, warning for large ones, link for URL-type, and include_data option to skip data fetch. No contradictions.

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 moderately detailed with a summary line, then detailed conditions and parameter docs. Every sentence adds value, though slightly verbose; could be tightened.

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 presence of an output schema (so return values not needed), two parameters clearly explained, and full behavioral coverage, the description is complete 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%, requiring description to compensate. The description explains both parameters: attachment_id as the id, and include_data as a boolean to control base64 fetch, adding meaning far beyond the schema's type and default.

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 reads an ir.attachment, specifying that metadata is always returned and base64 content is included when the attachment is small enough. This distinguishes it from sibling tools like read_records which read generic records, and none of the other siblings handle attachments 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?

The description explains when to use the tool (reading attachments), provides conditions for different attachment types (binary vs URL) and size thresholds, and clarifies the include_data parameter. It does not explicitly state when NOT to use it or mention alternatives, but the context is clear.

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

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

No annotations provided; description only indicates a read operation but does not mention permissions, rate limits, error handling, or behavior for missing IDs.

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 purpose, no filler words. Every sentence 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?

With 3 parameters (2 required), no schema descriptions, and an output schema present, the description is too brief. It lacks detail on return values, pagination, or differentiation from sibling tools.

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

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

Only fields parameter is hinted ('Pass `fields` to limit columns'), but model and ids are not explained. Schema coverage is 0%, so description should compensate more.

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

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

Description clearly states 'Fetch specific records by their ids' with a specific verb and resource, and distinguishes from siblings like search_read by specifying fetching by IDs.

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

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

No guidance on when to use this tool vs alternatives like search_read or get_model_fields. No exclusions or contexts provided.

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

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

With no annotations, the description carries the full burden. It transparently explains the report composition (aging buckets, overdue share, top customers, verdict) and the timezone default. The word 'Report' implies a read-only operation, though it doesn't explicitly state that no data is modified.

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

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

The description is front-loaded with a one-sentence summary, followed by a compact paragraph explaining the report logic and a well-structured Args list. Every sentence earns its place; no fluff.

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

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

Given the output schema exists, the description doesn't need to explain return values. It covers the report's scope, the aging bucket definitions, the verdict logic, and all parameters, making it fully sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does so thoroughly: each of the five parameters is documented with its meaning and default value, including the verdict threshold semantics for overdue_pct_at_risk and overdue_pct_off_track.

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

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

The description opens with a specific verb+resource: 'Report AR/AP aging and who owes what, in one call.' It then details the aging buckets and verdict, clearly distinguishing this tool from sibling report tools like inventory_risk or business_pulse by focusing on receivables/payables aging.

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 clearly implies the tool is for AR/AP aging reports, and the first sentence states a use case. However, it does not explicitly name alternative tools or state when not to use it, so it falls short of explicit usage guidelines.

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 the tool performs server-side aggregation over sale.order records, computes deltas, includes a verdict, and mentions the optional trend series. It does not explicitly state side effects or permissions, but as a read-only report, the description gives sufficient behavioral insight beyond what is visible in the schema.

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

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

The description is compact yet comprehensive: a one-sentence summary, a concise list of output components, then a clear Args block. No word is wasted; each sentence/parameter earns its place. The structure is front-loaded with the main purpose and flows logically.

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 (7 parameters) and the presence of an output schema, the description provides all necessary context: what is produced, parameter semantics, and even edge-case behavior. The output schema covers return structure, so the description does not need to repeat it. The only minor gap is explicit usage alternatives, which is already accounted for in the Usage Guidelines dimension.

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 fully compensate. It does: every parameter (period_days, stale_quote_days, top_n, timezone_offset, growth_threshold_pct, company, trend_weeks) is explained with its purpose, default, and in some cases the meaning of special values (e.g., trend_weeks=0 disables the query). This is exemplary.

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

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

The description opens with a clear, specific statement: 'Report how sales are going versus the previous period, in one call.' It then enumerates the exact outputs (deltas, top customers/products, stale-quote count, verdict), making it unambiguous what the tool does. This distinguishes it from sibling tools like pipeline_review or business_pulse, which focus on different metrics.

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

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

The description implies usage for sales performance comparisons with 'in one call' and lists the report components, but it does not explicitly state when to prefer this tool over alternatives. No exclusions or alternative tool names are mentioned, so the agent must infer the appropriate context from the description alone.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as performance impact, mutability, or return behavior. It only states the basic function.

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, concise but lacks necessary detail. It is not overly verbose, but the brevity reduces its helpfulness.

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 purpose with two parameters, yet the description does not mention the return format (e.g., an integer count) even though an output schema exists. Context signals indicate an output schema is present, but it is not referenced in the description.

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

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

The description mentions 'domain filter' but does not explain the syntax or formatting of the domain parameter. With 0% schema description coverage, it adds minimal value beyond the parameter 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 clearly states the tool counts records matching a domain filter. It uses a specific verb and resource, but does not explicitly differentiate from sibling tools like 'search_read' which also uses model and domain.

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

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

No guidance on when to use this tool versus alternatives. For example, it does not mention that this tool is for counting only, while 'search_read' returns records.

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

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

No annotations provided, so the description carries the full burden. It discloses important behavioral traits: limit is 'capped by ODOO_MAX_RECORDS', omitting fields 'can be large', and domain 'Defaults to all records'. However, it does not explicitly state read-only nature, permissions, rate limits, or error behavior. Some transparency, but 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 concise and well-structured: a one-line summary followed by an Args section with each parameter on its own line. Every sentence provides useful information, no fluff. The example domain list is particularly helpful and 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 has 6 parameters, no annotations, and an output schema (which handles return values), the description is complete: it explains all parameters, their defaults, the record cap, and the field omission caveat. It provides enough context for an agent to invoke the tool correctly without requiring external knowledge.

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 explain parameters. It thoroughly covers all six: model with example, domain with format and example, fields with caveat, limit with cap, offset for pagination, and order with example. This fully compensates for the schema's lack of descriptions, adding significant meaning.

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

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

The description clearly states the tool's function: 'Query records from an Odoo model.' This is a specific verb (query) + resource (records from an Odoo model). While it doesn't explicitly distinguish from sibling read_records, the focus on 'query' with domain filters implies search rather than direct read. Clear but no explicit sibling differentiation.

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

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

Usage guidance is implied through parameter descriptions (e.g., domain for filtering, limit/offset for pagination) but there is no explicit when-to-use vs alternatives like read_records. The description mentions behavior (defaults, caps) but not decision criteria. Thus, implied usage only.

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 thoroughly discloses behavior: fetches active subtasks, filters by stages and single assignment, categorizes by deadline, and returns plain-text. No side effects mentioned, but appropriate for a read-only 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?

Front-loaded with main purpose, followed by a brief explanation and clear parameter list. Every sentence adds value; no extraneous text.

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

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

Given 4 parameters, no annotations, and an output schema present, the description covers the categorization logic and return type well. Minor lack of example output, but output schema likely fills 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 coverage is 0%, but the description compensates by explaining each parameter's purpose, default values, and usage (e.g., 'ilike match' for project, UTC offset for timezone). Adds meaning beyond the schema.

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

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

Clearly states 'Generate a daily standup digest for a project' with verb and resource. The description explains the internal logic but does not explicitly differentiate from sibling tools like 'project_status_report'.

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 on when to use this tool versus alternatives. The description implies usage for daily standups but lacks when-not-to-use or alternative tool 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 adequately discloses behavior by stating it composes records, computes metrics, and returns a verdict, implying it is a read-only report. However, it does not explicitly declare that no data is modified or mention required permissions. The explanation of the algorithmic logic partially compensates for the lack of annotations.

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

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

The description is structured with a brief summary line followed by a paragraph and then the Args section. Every sentence adds value, and the information is front-loaded. There is no filler or redundancy.

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

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

The description covers the tool's purpose, logic, and all parameters comprehensively. Given that an output schema exists, the description appropriately does not detail return values but provides enough context. For a report tool with seven optional parameters, the description is 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 description provides a detailed 'Args' section explaining each parameter's purpose, behavior, and default values, such as 'lookahead_days' defining 'due soon' and 'subtasks_only' focusing on subtasks. Since the schema has 0% coverage, this fully compensates and adds significant meaning beyond the schema's type/name info.

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 begins with a clear verb ('Report') and resource ('who is over- or under-loaded'), and the subsequent explanation distinguishes it from sibling tools that handle other reports or CRUD operations. It states the tool produces a composite workload analysis, which is unique among the siblings.

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

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

The description clearly implies when to use the tool (to get a per-assignee load report in one call), but it does not explicitly mention when not to use it or suggest alternatives like search_read for detailed task lists. The context is sufficient for an agent to infer appropriate usage.

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

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

Discloses the preview/write behavior (dry-run unless confirm=True), which is critical for an update tool. No annotations provided, so description carries full burden; it clearly explains the mutation and confirmation mechanism.

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?

Extremely concise; uses structured Args format with clear bullet points. Every sentence adds value. 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?

Covers core functionality, parameters, and preview behavior. Includes constraint on model. Does not mention potential errors or limitations (e.g., validation of values). Output schema exists, so return values are not required.

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

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

With 0% schema description coverage, the description fully compensates by explaining each parameter's meaning: model must be in writable models, ids are record IDs, values is field mapping, and confirm controls dry-run.

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?

Clearly states it updates records, can update one or more, and distinguishes from sibling tools like create_record and delete_records. The description uses specific verb 'update' and resource '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?

Provides context about when to use (updating records) and a constraint (model must be in ODOO_WRITABLE_MODELS), but does not explicitly state when not to use or compare to alternatives.

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