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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds a vague hint of multi-instance scope ('fanned out across instances') but doesn't disclose additional behaviors like output aggregation or performance implications. It doesn't contradict annotations, and the annotation coverage reduces the burden, so a middling score 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 extremely concise (one phrase), but it's cryptic and lacks structure. It doesn't front-load a clear purpose; instead, it uses jargon ('partner-network sweep') that obscures meaning. Conciseness is present but at the expense of clarity, making it only minimally acceptable.

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 (multi-instance, aging direction, top-partner filtering) and the availability of an output schema, the description should explain the aggregation behavior and scope. It fails to describe what 'fanned out' means operationally, how instances are selected, or what the response contains. The schema and annotations help, but the description leaves critical gaps for 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?

Schema coverage is 100% — all four parameters (as_of, direction, instances, top_partners) have detailed descriptions. The description adds no extra meaning about parameters, so the baseline of 3 applies; it neither enriches nor harms parameter understanding.

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 cryptic language like 'fanned out across instances' and 'the partner-network sweep' without specifying that it's a read-only AR/AP aging query across multiple instances. It doesn't clearly state the resource or action, making it hard to distinguish from sibling tools like receivable_payable_aging or accounting_health_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?

No guidance is provided on when to use this tool versus alternatives (e.g., single-instance aging tools or other cross-instance queries). The description gives no context for selecting it based on use case, prerequisites, or exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds no extra behavioral context, such as the meaning of 'open' or that it only returns counts without detail, and it says nothing about the optional 'instance' parameter's effect on results.

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 conveys the core purpose without padding. It is appropriately terse and front-loaded, though it could benefit from a bit more structure or a second sentence for context.

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

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

Given the presence of an output schema, the return format may be documented there, but the description remains incomplete in core areas: it does not explain the 'instance' parameter, does not clarify the tool's single-instance scope versus siblings, and offers no usage guidance. The description is too minimal to be fully self-sufficient.

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 one optional parameter 'instance' with no description, and the schema description coverage is 0%. The tool description also fails to explain what 'instance' refers to or how it affects the output, leaving the agent without essential information for correct invocation.

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 receivable/payable item counts and draft invoice backlog, identifying its resource and action. However, it does not explicitly distinguish it from sibling tools like 'receivable_payable_aging' or 'accounting_health_across_instances', which likely cover related but different scopes.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that it is likely for a single instance versus across instances, nor does it note any prerequisites or exclusions. The user is left to infer usage from the name alone.

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

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

The description says 'Read-only', which is consistent with the annotations (readOnlyHint=true, destructiveHint=false, idempotentHint=true). It adds behavioral context by stating the operation 'fans out across instances' and produces 'combined grand totals', which is beyond what annotations provide. However, it does not disclose other behavioral aspects like potential latency, failure semantics, or how 'instances' is interpreted by default.

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

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

The description is a single concise sentence with no filler words. It front-loads the key qualifier 'Read-only' and immediately conveys the core behavior. It is appropriately sized for the information it delivers, though it sacrifices detail for brevity.

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 cross-instance fan-out, five parameters, and no parameter descriptions, the one-line description is insufficient. It does not mention how instances are specified, what measures or group_by mean, or how domains are applied. An output schema exists, but the description alone leaves too many operational gaps for an agent to use the tool confidently.

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

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

Schema description coverage is 0% and the description does not explain any of the five parameters (model, domain, group_by, measures, instances). The only hint is the phrase 'across instances', but it does not clarify parameter formats, defaults, or relationships. With no parameter documentation in either schema or description, the agent is left to guess semantics.

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

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

The description clearly indicates the tool performs an aggregation operation ('aggregate') that is 'fanned out across instances' with 'combined grand totals', distinguishing it from single-instance aggregation tools like aggregate_records and from cross-instance search tools like search_across_instances. However, it is phrased as a noun phrase rather than an explicit verb+resource construction, which slightly reduces clarity.

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 is for cross-instance aggregation scenarios ('across instances', 'combined grand totals'), but it does not explicitly state when to use this tool instead of alternatives or when not to use it. Sibling tool names provide context, but the description itself offers no direct comparison or exclusion.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint as false. Description adds version-specific implementation details but does not disclose additional behavioral traits beyond what annotations provide.

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

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

Two sentences, front-loaded with purpose, second sentence adds concise implementation detail. No redundant or irrelevant 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?

Though output schema exists, the description is too brief for a 9-parameter aggregation tool. It does not explain how to use domain, measures, order, or lazy parameters. Adequate for basic understanding but incomplete for effective usage.

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% description coverage for 9 parameters. Description mentions 'groupby/sum/count' but does not explain any parameter meanings or usage. Does not compensate for 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?

Description clearly states it aggregates Odoo records using Postgres groupby/sum/count, which is a specific verb+resource. It distinguishes from siblings like search_records (raw data) and aggregate_across_instances (cross-instance). The mention of Odoo versions 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?

No explicit guidance on when to use vs alternatives. Implied usage is for server-side aggregation rather than fetching individual records, but no exclusions or alternative tool references 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?

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds no further behavioral context (e.g., limitations, performance considerations). With annotations present, this is adequate but not exemplary.

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 efficiently conveys purpose and outcomes. No unnecessary words 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 three parameters (one required, two optional) and an output schema, the description provides a high-level goal but omits practical details like input constraints, expected version values, or output format. It is barely adequate for agent 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%, so the description must compensate. However, it only mentions 'log errors' without defining 'log_text' or explaining optional version parameters. The agent lacks details on expected input format or version syntax, which is insufficient for 0% 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 clearly states the tool's purpose: classifying Odoo upgrade log errors into three categories with fix suggestions. It uses a specific verb ('classify') and resource ('Odoo install/update log errors'), differentiating it from siblings like 'health_check' or 'upgrade_risk_report' which cover other 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 for analyzing upgrade logs, but provides no guidance on when to use this tool versus alternatives like 'upgrade_risk_report' or 'scan_addons_source'. No explicit when-not or context for selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety expectations. The description adds 'validated,' implying some checking of conditions, but does not explain other behavioral aspects like whether it returns a string or list, or any constraints. Since annotations cover the key safety traits, the description adds minimal extra behavioral clarity.

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

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

The description is a single, compact sentence with no filler. It efficiently conveys the core action and input. Every word contributes meaning, making it appropriately 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 tool has three parameters, one required, and an output schema, yet the description does not explain any of the parameters beyond a vague reference to conditions. It lacks details on how the logical operator or fields metadata influence the output. Even with annotations and an output schema, the description is incomplete for a tool that constructs complex domains.

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 explaining parameters. It only mentions 'structured conditions,' which vaguely maps to the 'conditions' parameter, but completely omits the 'fields_metadata' and 'logical_operator' parameters. Without any elaboration on how these parameters affect domain construction, parameter semantics are severely under-explained.

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: 'Build a validated Odoo domain from structured conditions.' The verb 'build' and resource 'Odoo domain' are specific, and the mention of 'validated' adds a unique aspect. It distinguishes from sibling tools like search_records, which perform queries, whereas this constructs a domain filter.

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 mention prerequisites, when it is appropriate to build a domain, or suggest any alternative tools. The single sentence is purely declarative without usage context.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, providing a clear safety profile. The description adds minimal behavioral context beyond stating the purpose; it does not discuss performance, caching, or side effects.

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

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

The description is a single concise sentence that is front-loaded with the verb and resource. It is efficient and avoids 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?

With 3 parameters, an output schema, and clear annotations, the description provides adequate context. It covers the primary purpose but could mention the output structure or typical use cases briefly.

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

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

Schema coverage is 100%, so the input schema already documents all parameters. The description does not add meaning beyond the schema; it merely restates the tool's purpose.

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 'Report' and the resource 'expected modules, models, and safe discovery calls for a business pack'. It distinguishes this tool from siblings like health checks or search tools by its specific reporting scope.

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

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

No guidance is provided on when to use this tool versus alternatives, when not to use it, or any prerequisites. The description simply states what it does without contextual usage advice.

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

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

The description directly contradicts the annotation readOnlyHint: true. Cancelling a task is a mutating action, not read-only. The description adds no behavioral context beyond the basic action, and it does not explain side effects like whether cancellation is irreversible or what happens to the task's status. This is a serious inconsistency with the annotations.

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

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

The description is a single concise sentence with no unnecessary words. It is front-loaded with the core action and resource. 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 tool's simplicity (one parameter) and the existence of an output schema, the description could be minimal, but it omits critical usage context and contradicts the annotations. It fails to provide guidance on when to cancel tasks or what the expected outcome is, making it incomplete for an agent to use 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 description provides no information about the task_id parameter beyond its name. Schema description coverage is 0%, so the description must compensate, but it does not explain how to obtain a task_id or what format is expected. The single parameter is self-explanatory by name, but the description adds zero semantic 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?

The description clearly states the tool's function: cancel a pending or running background task. It uses a specific verb ('cancel') and a specific resource ('background task'), and it distinguishes itself from sibling tools like submit_async_task, get_async_task, and list_async_tasks by being the cancellation 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 gives no guidance on when to use this tool versus alternatives. It does not mention checking task status first (e.g., via get_async_task), nor does it state that tasks should be cancelled only when they are no longer needed. There is no discussion of 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?

Adds value beyond annotations by detailing the approval token requirement and the env variable toggle. Description aligns with annotations (readOnlyHint false, destructiveHint true).

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 succinct sentences front-loading the primary action and usage variants, 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?

Despite moderate complexity (10 params, no param descriptions), the description omits critical parameter details and does not leverage the existing output schema to explain behavior. Agent would struggle to correctly populate all fields.

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 fails to explain most parameters (body, model, record_id, etc.), only mentioning 'approval'. Leaves agent with insufficient parameter-level understanding.

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', resource 'chatter message', and target 'mail.thread record', distinguishing it from siblings like preview_write.

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

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

Provides explicit guidance on two modes: default requires approval token from preview, direct mode bypasses with environment variable. Does not compare to alternative tools but gives clear usage context.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds meaningful behavioral context by listing specific check types and stating it operates on one Odoo model. However, it does not explain potential resource impact or return format limitations.

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 front-loaded with the core verb and resource. It is concise, includes essential details, and has 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?

With 5 parameters and no schema descriptions, the description provides high-level purpose but insufficient detail for correct invocation. The output schema exists but is not provided; however, the description does not explain return values. The tool's full usage context is 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 parameter description coverage is 0%. The description mentions check types (duplicates, missing required, etc.) which likely correspond to the 'checks' parameter, but does not explain other parameters (instance, key_fields, sample_limit) or their formats. The agent must infer from 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 runs read-only data-quality checks on one Odoo model and lists specific check types (duplicates, missing required values, orphaned references, format anomalies). This distinguishes it from sibling tools like search_records or aggregate_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 description implies use for data-quality inspection but does not provide explicit when-to-use or when-not-to-use guidance compared to alternatives like diagnose_odoo_call or inspect_model_relationships. Usage is inferred but not clarified.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructiveness; the description confirms the diagnostic nature but adds no further behavioral details (e.g., output volume, execution cost).

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 single-sentence description is concise, front-loaded with the verb and resource, and contains no redundant information.

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

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

For a 9-parameter tool with full schema and an output schema, the brief description is mostly adequate, though it could briefly mention the nature of the diagnostic output (e.g., 'returns ACL analysis').

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

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

Schema coverage is 100%, so the description does not need to explain parameters; it adds no extra meaning beyond what the schema already provides, meeting the baseline.

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

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

The description clearly states the verb 'diagnose' and the resource 'ACL and record-rule visibility for an Odoo model', making the tool's specific purpose distinct from sibling diagnostic tools.

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

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

No guidance is provided on when to use this tool versus alternatives like diagnose_odoo_call or when to avoid it; the description lacks context for decision-making.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds 'without executing it', reinforcing safety but providing no additional behavioral details beyond what annotations convey.

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 immediately conveys the tool's purpose. No unnecessary words or 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?

Given the tool has 10 parameters and an output schema, the description is brief but sufficient to understand the core functionality. However, it could briefly mention that the tool analyzes potential issues without side effects, which would improve 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 100%, so baseline is 3. The tool description adds no extra meaning beyond the parameter descriptions in the schema (e.g., it doesn't explain how 'metadata' or 'transport' affect diagnosis).

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 'Diagnose an Odoo model call without executing it', clearly defining the action (diagnose), the resource (Odoo model call), and the key constraint (no execution). This distinguishes it from sibling tools like 'execute_method' which performs actual execution.

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 diagnosis, but does not provide explicit guidance on when to use this tool versus alternatives (e.g., 'execute_method', 'preview_write'). There is no mention of use cases 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?

Description adds no behavioral context beyond what annotations already provide (destructiveHint: true). No mention of side effects, reversibility, or permissions. Annotation covers destructiveness, so description adds minimal value.

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, very concise and front-loaded. However, the brevity sacrifices necessary detail, making it less useful than a slightly longer but more informative description.

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 an output schema (not provided here) and annotations, the description is too minimal. For a destructive operation with a complex parameter (approval object), it should explain what the approval object is (e.g., from preview_write response) and confirm's function.

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 provides no explanation of parameters (confirm and approval). The approval object is not described, nor is the role of the confirm boolean. Critical gap for a tool with nested objects.

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: executing a previously previewed and confirmed write. It uses specific verb 'execute' and resource 'standard write', and distinguishes from siblings like preview_write and validate_write.

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

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

Implies prerequisite of a previewed and confirmed write, but does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. Lacks guidance on required prior steps.

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

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

Annotations already flag destructiveHint: true and readOnlyHint: false, indicating the tool can modify data. The description adds no behavioral context beyond the annotations—no mention of side effects, permissions required, or safety considerations. Given the annotations, the description should at least reinforce the destructive nature or clarify when destruction might occur.

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, which is concise but not optimally structured. It could be expanded with key information (use case, restrictions) without becoming verbose. Front-loads the core action but omits important guidance.

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 an output schema, the description fails to explain return values, error behaviors, or side effects. For a destructive, open-world tool with 5 parameters and many siblings, this is insufficient. The description should at least mention safety warnings or when to prefer this over similar tools.

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

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

The input schema has 100% description coverage, with each parameter (model, method, args, kwargs, instance) already described. The tool description adds no additional meaning beyond what the schema provides. Per the rubric, baseline is 3 since schema coverage is high.

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 'Execute a custom method on an Odoo model' clearly identifies the action (execute) and the resource (custom method on Odoo model). It distinguishes from siblings like 'execute_approved_write' (specific to writes) and 'diagnose_odoo_call' (testing). However, it could be more precise about what constitutes a 'custom method' versus blocked methods (create/write/unlink), which are noted only in the parameter schema.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, comparable tools (e.g., 'execute_approved_write' for safe writes, 'read_record' for reading), or scenarios where this tool is inappropriate. The blocked methods are only stated in a parameter description, not in the tool 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it's a safe, non-mutating operation. The description adds no further behavioral context, but with the annotations present, the baseline is acceptable. No contradiction observed.

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

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

The description is a single sentence with no redundancy. Every word contributes to the purpose. It is efficiently 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?

Despite having an output schema (not shown), the description fails to provide essential context about input format (e.g., what should 'requirements' look like), optional parameters' effect, or expected behavior when optional params are omitted. For a tool with 6 parameters and a specific analysis purpose, this is 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%, meaning no parameter descriptions in the schema. The description does not elaborate on any parameter, including the required 'requirements'. Parameters like 'available_fields', 'available_models', and others have names that hint at meaning, but the agent gets no format, constraints, or examples. This is a critical gap.

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

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

The description clearly states the tool's action ('classify') and resource ('Odoo requirements'). It specifies the output as 'fit/gap implementation buckets', which is specific. However, it does not differentiate from siblings like 'data_quality_report' or 'upgrade_risk_report', which could also analyze requirements in different ways.

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. It does not mention prerequisites, context, or typical scenarios. The single-sentence description lacks any usage recommendations.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and non-destructive. The description adds 'without network access', clarifying local execution. It does not contradict annotations. Additional context like auth needs or rate limits is not needed given the annotations.

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

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

The description is a single concise sentence that effectively communicates the tool's purpose and key behavioral trait (no network access). It is well front-loaded with 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 having an output schema, the description lacks context about what JSON-2 is, what fields the preview includes, and how to correctly fill the 7 input parameters. The agent may struggle to invoke the tool correctly without additional guidance.

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

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

Schema description coverage is 0%, so the description must compensate. It provides no information about parameter meanings, leaving the agent to infer from names alone. Generic parameters like 'args' and 'kwargs' are particularly ambiguous.

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 'Build', the resource 'JSON-2 request preview', and the constraint 'without network access'. It distinguishes the tool from siblings, none of which mention JSON-2 or payload preview.

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

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

The description implies the tool is used to generate a preview of a request payload, but it does not explicitly state when to use it vs alternatives or provide guidance on prerequisites or conflicts. Usage context is implied by the tool name and description.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds the behavioral context of polling a background task's status and result, but it does not disclose any additional traits such as behavior when the task is not found, retry logic, or output specifics. Since annotations carry the safety burden, the description provides minimal but adequate transparency beyond the annotations.

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

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

The description is a single concise sentence that is front-loaded with the action 'Poll' and clearly states the resource. It contains no unnecessary words and is easy to parse.

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

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

Given the simple structure (one parameter), the presence of an output schema, and annotations covering safety, the description is largely complete. It accurately conveys the tool's purpose and operation. It lacks explicit workflow context (e.g., referencing submit_async_task), but for a simple polling tool, the description is sufficiently comprehensive for an agent to understand and invoke it.

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

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

Schema description coverage is 0% and the description does not mention parameters at all. The only parameter, task_id, is self-explanatory from its name and type, but the description does not compensate for the lack of schema descriptions by explaining how to obtain or use the task_id, leaving the agent to infer its meaning from 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 "Poll a background task's status and result" uses the specific verb 'Poll' and clearly identifies the resource (background task's status and result). It distinguishes from sibling tools like submit_async_task, cancel_async_task, and list_async_tasks by indicating a targeted retrieval of a single task's status and result.

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 checking the status of an asynchronous background task, but it does not explicitly state when to use this tool versus alternatives such as list_async_tasks, nor does it mention exclusions. It provides no direct guidance on the workflow (e.g., after submitting a task) or when to prefer another 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?

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds no additional behavioral context (e.g., pagination, filtering behavior, or performance implications).

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, which is concise but lacks necessary detail. It is appropriately front-loaded but underinformative.

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 five parameters and no schema descriptions, the description is incomplete. It fails to explain parameters, output schema, or usage nuances, leaving agents without essential context.

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

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

Schema description coverage is 0%. The description does not explain any of the five parameters (model, instance, relevance, max_fields, field_names), providing no added meaning beyond the schema's field 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 uses a specific verb ('Get') and resource ('field metadata for a specific Odoo model'), clearly distinguishing it from sibling tools like list_models or search_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?

No guidance on when to use this tool versus alternatives such as inspect_model_relationships or schema_catalog. No context about prerequisites or when not to use it.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds minimal behavioral context beyond 'bounded', leaving the precise scope unclear. No contradiction with annotations.

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

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

A single, concise sentence front-loads the core action. No extraneous text, and every word is meaningful.

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?

While the output schema exists (reducing need to describe returns), the term 'bounded profile' is vague. The description could clarify what is included (e.g., version, user info). Adequate but not excellent.

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?

All three parameters have descriptions in the input schema, achieving 100% coverage. The tool description does not add extra meaning beyond what the schema already provides.

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

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

The description uses a specific verb ('Read') and resource ('bounded profile of the connected Odoo environment'), clearly distinguishing this tool from sibling tools like 'get_model_fields' or 'list_instances'.

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 'health_check' or 'list_models'. An agent receives no context about prerequisites or preference 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?

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by clarifying that it reports 'non-secret' runtime safety posture, which helps the agent understand what information it will get. 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 a single, concise sentence that states the tool's purpose without unnecessary words. It is front-loaded with the action and resource.

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

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

Given the tool's simplicity (no parameters, presence of output schema), the description provides complete context: it reports the server's non-secret runtime safety posture. No additional details are needed.

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 0 parameters, and the input schema is fully descriptive (100% coverage). Per guidelines, baseline is 4 for 0 parameters; the description does not need to add parameter 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 uses a specific verb ('Report') and clearly identifies the resource ('this MCP server's non-secret runtime safety posture'). It distinguishes from sibling tools like 'accounting_health_summary' by focusing on general server safety rather than accounting-specific 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 lacks any guidance on when to use this tool versus alternatives (e.g., when to use 'health_check' vs 'accounting_health_across_instances'). No explicit context or exclusions 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 annotations readOnlyHint=true, idempotentHint=true, and destructiveHint=false, the description adds context by specifying the operation is 'local' and builds a BM25 index, suggesting side effects are confined to the local session. This clarifies that while it's a read operation, it sets up a searchable structure. It does not contradict any annotation and adds useful nuance about scope, though it could mention memory/performance implications.

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 of 13 words, free of fluff. Every word earns its place, immediately conveying the action and outcome. It is perfectly sized for quick consumption.

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

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

The tool has 6 parameters (moderate complexity) and an output schema exists. The description covers the overall purpose but omits any detail about parameters, return value structure, or edge cases like what happens with replace=true. Given the annotations already declare safety, this is adequate for a basic understanding but leaves gaps in knowing how to set up the index correctly, making it 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 makes no mention of any parameters. All six parameters (limit, model, domain, fields, replace, instance) are left unexplained. Since the schema provides no defaults or descriptions, the description needed to compensate but entirely fails to clarify what these parameters do or how they interact. This leaves the agent guessing on parameter usage.

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 'fetch' and 'build' with concrete resources: 'a bounded slice of records' and 'a local BM25 knowledge index'. This clearly distinguishes it from sibling tools like search_knowledge and knowledge_stats, as it focuses on indexing rather than querying. It tells exactly what the tool does.

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 instead of alternatives. It does not mention exclusions, prerequisites, or compare to similar tools like search_knowledge or list_instances. The description only states the action without contextual 'when' or 'when not to use', so it fails to help an agent decide between this and related tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds no additional behavioral context (e.g., that it returns relationships, no side effects). With rich annotations, a 3 is appropriate as the description complements but doesn't expand.

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. It is concise, though it sacrifices completeness. It could benefit from a brief explanation of parameters or usage context.

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

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

Given the tool has 6 parameters (1 required) and no parameter documentation in the description, the description is incomplete. Although an output schema exists, the parameter semantics gap is significant for a tool with many 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%. The description does not explain any of the six parameters (e.g., instance, fields_metadata, include_computed). Parameter names alone are insufficient for accurate usage; e.g., 'instance' is ambiguous without explanation.

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 'Inspect model relationships and required field metadata' clearly states the verb 'inspect' and the specific resources 'model relationships and required field metadata'. It distinguishes from siblings like 'get_model_fields' which focuses on fields, not relationships.

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. Among siblings, there are tools like 'get_model_fields', 'schema_catalog', and 'lookup_model_history', but no comparisons or exclusions 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?

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, which already cover safety. The description adds that it reports 'local' knowledge index, which is useful context, but does not elaborate on what exactly is included (e.g., budget specifics, whether it aggregates across instances). No contradiction.

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 states exactly what the tool does. No fluff, perfectly front-loaded.

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

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

Complexity is low with 0 parameters and a clear purpose. The output schema exists, so return values are presumably documented there. The description covers the main function (sizes and budget) but could mention whether it's instance-specific or aggregated, though 'local' hints at instance-level. Overall complete enough.

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 0 parameters, so schema coverage is 100% trivially. The description adds no parameter details because none exist. Baseline for 0 params is 4, and the description is adequate.

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 local knowledge index sizes and document budget, which is specific and distinguishes it from siblings like index_knowledge and search_knowledge. It lacks a verb like 'get' but the purpose is clear.

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

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

The description implies usage for checking knowledge index stats, but does not explicitly state when to use this tool versus alternatives (e.g., index_knowledge or search_knowledge). No exclusions or contextual triggers 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds the newest-first ordering, which is useful, but it does not disclose other behaviors like result limits, pagination, or what 'recent' means. This goes slightly beyond annotations but is 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, concise sentence that states the action, resource, and ordering. It is front-loaded and contains no redundant information.

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

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

For a zero-parameter list tool with an output schema and good annotations, the description is adequate. The only slight gap is the vague term 'recent' without a defined limit, but the overall simplicity and existing structured data make it sufficiently 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 tool has zero parameters, so the baseline is 4. The description does not need to add parameter meaning, and since there are no params, no additional info is required.

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

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

The description clearly identifies the action (list), the resource (background tasks), and the ordering (newest-first). It distinguishes from siblings like get_async_task (fetch specific) and cancel_async_task (cancel), so the purpose is 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?

No guidance is provided on when to use this tool versus alternatives such as get_async_task or cancel_async_task. The description simply states what it does without context for selection or exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds the key behavioral trait 'without credentials,' which implies no authentication is required and no sensitive data is exposed. This complements annotations effectively without contradiction.

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, concise sentence that conveys the entire purpose without unnecessary words. It is optimally front-loaded for quick comprehension.

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

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

The description is sufficient for a simple, parameterless tool. It states what the tool returns (instance names) and that it is safe. An output schema exists, so return format details are covered there. Could be more complete by noting that the list is static or cached, but overall adequate.

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?

No parameters exist, so schema coverage is 100%. The description does not need to elaborate. Baseline for zero parameters is 4, as no additional parameter meaning is required.

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 'List configured Odoo instance names without credentials,' specifying the verb (List) and resource (Odoo instance names). It distinguishes from sibling tools like list_models or list_async_tasks by focusing on instances and emphasizing 'without credentials'.

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. It does not mention scenarios like listing instances for monitoring or comparison, nor does it exclude cases where credential info is needed. Sibling tools exist for broader operations (e.g., aggregate_across_instances), but no differentiation 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds no behavioral traits beyond the filtering behavior implied by the query parameter, and does not mention latency, auth requirements, or 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?

A single, clear sentence with no wasted words. The core action and optional filter are front-loaded, making it easy to scan.

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 (3 optional params, output schema present), the description is adequate but minimal. It does not clarify what the output contains (e.g., model names only vs. full details) or how 'limit' and 'instance' affect results, leaving some ambiguity.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It only hints at 'query' for name filtering but provides no explanation for 'limit' or 'instance'. The output schema exists but is not described, so the agent cannot infer return structure from this description.

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

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

The description uses a specific verb 'List' and clearly identifies the resource 'Odoo models', with the optional name filtering hint. It distinguishes the tool from siblings like 'search_records' or 'get_model_fields' by focusing on listing models themselves.

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_records' or 'get_model_fields'. The description implies a use case (listing models with optional filtering) but does not specify exclusions or preferred contexts.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description confirms a safe lookup. It adds the detail of looking up history, which is consistent. No contradictions, but could mention limitations if any.

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 action and resource. No wasted words. Example enhances understanding without bloating.

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 tool with one required parameter, clear annotations, and an existing output schema, the description is complete. No need to explain return values.

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 fully compensates by explaining that the 'name' parameter can be an old or new model name, with a concrete example. Adds significant semantic 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?

The description clearly states the action (look up), the resource (Odoo model rename/removal history), and the method (by old or new model name). An example is provided, and it distinguishes from sibling tools like list_models or get_model_fields.

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 (to find rename/removal history) but does not explicitly state when not to use or provide alternatives. It gives a clear use context but lacks exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the key behavioral trait 'without executing it,' which aligns with annotations but does not provide additional details like authorization needs or rate limits. This is adequate given the annotation coverage.

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 and contains no unnecessary words. Every element serves a purpose, 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?

Despite having an output schema (not shown), the description lacks guidance on parameter usage and return values. With 7 parameters and no schema descriptions, the description is insufficient for correct tool invocation, especially for an agent unfamiliar with the tool.

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

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

The input schema has 7 parameters with 0% schema description coverage, and the tool description provides no explanation of any parameter. Without compensating information, the agent cannot understand the meaning or proper usage of parameters like 'model,' 'operation,' 'values,' etc.

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 "Preview create, write, or unlink without executing it" clearly states the tool's purpose with a specific verb ('preview') and resource scope ('create, write, or unlink'). It distinguishes itself from sibling tools like 'execute_approved_write' and 'validate_write' that perform actual execution or validation.

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 you want to see the effect of a write operation without committing. It is clear from the context, but it does not explicitly mention alternatives or when not to use this tool, which would make it a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, so safety is clear. The description adds value by specifying that content is 'size-capped', which is crucial behavioral information not captured in annotations. It could be improved by noting the cap size or behavior when exceeded, but overall adds 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 sentence that efficiently conveys the tool's purpose and key behavioral details. It is front-loaded with the verb and resource, and every word contributes meaning. No superfluous 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?

Given the tool has 3 parameters, an output schema, and sibling tools that also read data, the description is minimally complete for a simple read tool. However, it lacks parameter explanations and does not clarify the return structure (though output schema may cover that). The size-cap info is good, but overall could be more 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?

With 0% schema description coverage, the description should explain what the three parameters (instance, include_data, attachment_id) mean and how they affect the operation. It does not do so. The description only mentions the overall action, leaving parameter semantics completely 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 uses a specific verb 'Read' and a precise resource 'ir.attachment', and it clearly states what is returned (metadata and size-capped base64 content). This distinguishes it from sibling tools like read_record or execute_method, which have different purposes.

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 reading attachments, but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives among the many sibling tools. The context is clear but lacks direct directives.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety and idempotency are covered. The description adds no extra behavioral context beyond stating it reads a record. With annotations, the burden is lower, but no additional details like return format or error cases are given.

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 gets straight to the point. It is front-loaded with the main action and resource, 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 is minimal but for a simple read tool with annotations covering behavior, it is fairly complete. However, the absence of parameter descriptions and usage guidance leaves gaps, especially given multiple sibling tools and optional 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%, meaning no parameter descriptions exist in the schema. The overall description does not explain any of the four parameters (model, record_id, fields, instance). For clarity, each parameter should be described; the description completely fails to do so.

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 a single Odoo record by model and ID. This distinguishes it from siblings like search_records (multiple records) and get_model_fields (metadata). The verb 'read' and resource 'single Odoo record' are specific.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, context, or that it is best for known record ID lookups. Sibling tools like search_records are not contrasted.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive, so the description doesn't contradict them. The description provides a good high-level behavior ('bucketed by days overdue') that complements annotations. However, it doesn't elaborate on side effects (though readOnly implies none) or specific data aggregation behavior, but given the annotations, this is adequate.

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 sentence, concise and to the point. It communicates the core function without fluff. It could maybe expand on the output, but for a report tool, this is appropriately short.

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

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

The description is minimal but an output schema is present, so return values don't need explanation. However, it doesn't mention the meaning of 'open-item lines' or the purpose of the 'limit' parameter, which could be ambiguous. The tool complexity is moderate (5 params, all documented), so more context would help. Given the output schema exists, it's acceptable but could be slightly more 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?

All parameters have descriptive schema descriptions: as_of (ISO date), limit (max lines), instance (optional Odoo instance), direction (receivable/payable), top_partners (max partners, capped). The description adds context by saying the report is 'bucketed by days overdue', which helps understand what 'as_of' and 'direction' mean. Since schema coverage is 100%, the parameter semantics are already well-covered, but the description reinforces the purpose.

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 produces an 'Aged receivable/payable report' with a specific structure (bucketed by days overdue). It effectively conveys the core purpose and distinguishes it from general reporting tools. However, it doesn't explicitly differentiate from sibling tools like `accounting_health_summary` or `business_pack_report`, which might also involve financial 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 description implies usage for generating aging reports but provides no guidance on when to choose this over alternatives or prerequisites (e.g., configured Odoo connection, instance). Given sibling tools like `accounting_health_summary`, explicit when-to-use guidance is missing. The schema mentions 'instance' and 'direction', but the description doesn't clarify typical use 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?

Annotations already mark the tool as read-only and idempotent. The description adds a key behavioral trait: 'without importing addon code', explaining it avoids side effects of importing modules.

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 that is concise and directly states the tool's purpose without 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?

With an output schema but no parameter details in the description, the tool is incomplete for effective use. The description should at least list what the returned data looks like or mention key 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%, yet the description provides no explanation of the three parameters (max_files, addons_paths, max_file_bytes). Users cannot infer their meaning or usage from the description.

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

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

Description clearly states the tool scans local Odoo addon source files without importing, using a specific verb and resource. It distinguishes from sibling tools that focus on data records or other operations.

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

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

No guidance on when to use this tool vs alternatives like read_record or inspect_model_relationships. The description lacks context for 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds value by stating that the tool builds and caches the catalog, implying that it is a read operation that may return cached data, and that it is bounded. This context enriches the understanding beyond annotations.

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

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

The description is a single, front-loaded sentence with no unnecessary words. Every word contributes to the purpose, making it highly concise and 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?

Given that an output schema exists and annotations cover safety, the description is mostly complete. However, it does not explain the caching behavior in detail or mention the bounded nature explicitly, which could be helpful for an agent to understand the tool's scope. Still, it is sufficient for a tool with well-documented parameters and schema.

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

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

Schema description coverage is 100%, so the schema documents all parameters fully. The description does not add any additional meaning or constraints beyond what the schema provides, meeting the baseline expectation.

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 ('Build and cache') and the resource ('bounded Odoo model schema catalog'), which is specific and informative. It distinguishes from sibling tools like 'list_models' or 'get_model_fields' by emphasizing caching and boundedness, but does not explicitly contrast with them.

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

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

The description gives no guidance on when to use this tool versus alternatives such as 'list_models', 'get_model_fields', or 'search_records'. No usage context, prerequisites, or exclusions 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds useful behavioral grounding with 'fanned out... merged and attributed', which explains the cross-instance orchestration and result attribution. It does not go into detail about attribution semantics or edge cases, but it complements the annotations well.

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?

This is a single, well-structured sentence that front-loads the key idea ('Read-only') and packs in scope and behavior without waste. It is concise while still being information-dense.

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?

Within its parent object schema and annotations, this description is reasonably effective, and an output schema covers return value semantics. However, main gaps are the lack of parameter semantics and no explicit guidance around when to select this instead of related search_records or aggregate_across_instances. It is minimally complete but not richly enough for a complex fan-out 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%, and the description provides essentially no parameter guidance. Parameter names like model, domain, instances, and limit_per_instance are somewhat self-explanatory, but the semantics of null defaults, the format of domain/instances, and how limit is applied are left unexplained.

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

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

The description uses a specific verb ('search'), names the resource (Odoo instances), and conveys a precise scope ('fan out across configured instances', 'merged and attributed'). It clearly distinguishes this from single-instance search_records and aggregate_across_instances.

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 'fanned out across configured Odoo instances' clearly indicates the main use case is multi-instance search. It does not explicitly name alternatives or list when not to use it, but the context is clear enough for an agent to choose it over search_records or aggregate_across_instances.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds no additional behavioral context such as search behavior (e.g., partial matching, case sensitivity) or result structure.

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, which is concise but lacks structure for a tool with multiple parameters. A more structured format (e.g., listing parameters briefly) would improve clarity without adding much length.

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 required parameter and an output schema, but the description does not mention the output schema or return format. It adequately addresses the core purpose but lacks details on optional parameters and results.

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 for the 'name' parameter implicitly but provides no details on 'limit' or 'instance'. The description only partially explains the parameters.

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

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

The description clearly states the action ('Search') and the resource ('employees') with a specific filter ('by name'). It distinguishes from sibling tools like search_records and search_across_instances by targeting employees 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 implies usage for searching employees by name but does not explicitly state when to use this tool versus alternatives like search_records or search_across_instances. No exclusions or when-not-to-use guidance is 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description does not add any behavioral context beyond what annotations provide, such as pagination or filtering 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 a single short sentence that is front-loaded with the key action and resource, containing 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?

Given the tool's simplicity, presence of an output schema, and comprehensive annotations, the description is sufficient for understanding the tool's purpose. It could mention that it returns a list of holidays, but the output schema 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 description coverage is 100% with each parameter adequately described. The tool description adds no additional parameter 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 searches for holidays within a date range. The verb 'Search' and resource 'holidays' are specific, and it distinguishes from sibling search tools like search_records or search_employee.

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 date-range holiday searches but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds algorithmic detail (BM25, local) without contradicting annotations, but does not elaborate on side effects or scope.

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

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

The description is a single, focused sentence with no redundancy or unnecessary 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?

While an output schema exists (so return values need not be explained), the description lacks parameter semantics and usage guidance, making it incomplete for effective 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 schema includes four parameters (query, model, limit, instance), but the description provides no explanation for any of them. This is a significant gap, and no compensation is made.

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 performs a search over indexed records with BM25 relevance ranking. The term 'local' distinguishes it from cross-instance search tools, though it could be more explicit about the scope.

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

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

No guidance is given on when to use this tool versus alternative search tools like search_records or search_across_instances. The 'local' hint is implicit but not elaborated.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. Description adds that it uses the search_read method and that query matches name/ref/email-like fields, providing context beyond annotations.

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

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

Single, front-loaded sentence efficiently conveys purpose and key feature (free-text query). No extraneous text; every word contributes.

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

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

With 8 parameters and existing output schema, description covers core search intent but omits details on filtering with domain, field selection, ordering, and pagination. Adequate but incomplete for complex 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 coverage is 0% so description must compensate. Only 'query' parameter receives partial description (matches across fields). Other seven parameters (limit, order, domain, etc.) are not described, leaving significant gaps.

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 'Search Odoo records with read-only search_read', specifying verb and resource. It distinguishes from sibling tools like search_across_instances by focusing on single-instance search.

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?

Description mentions optional free-text query but does not specify when to use this tool versus alternatives such as search_across_instances or model-specific searches. No explicit when-not or usage context.

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

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

Annotations already declare readOnlyHint=true, so the description reinforces that by saying 'read operation'. It adds context beyond annotations by specifying 'allowlisted' (implying restrictions), 'long-running' (performance characteristics), and 'background' (execution model). No contradiction exists, and the extra detail is valuable though it does not cover error handling or cancellation 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 a single, concise sentence with no redundant words. It delivers the core purpose effectively and is appropriately sized for a straightforward submission tool.

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

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

With an output schema present, the return value might be covered elsewhere, but the description fails to provide essential context about the operation allowlist, how to construct parameters, or whether an instance is required. For a tool that submits long-running tasks, users need to know what operations are permitted and how to structure inputs, which is missing. This makes the description incomplete for a 3-parameter tool with 0% schema coverage.

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

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

Schema description coverage is 0%, so the description carries full responsibility for explaining parameters. However, it only mentions 'operation' implicitly via the word 'operation' in the text, without defining what an operation is, how to specify parameters (params), or what instance refers to. The schema shows three parameters, but none are explained, making param semantics weak.

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 ('Run') and resource ('operation'), and adds qualifiers ('allowlisted', 'long-running', 'read', 'background') that distinguish it from sibling async tools like get_async_task, cancel_async_task, and list_async_tasks. It unambiguously communicates that this tool submits a background read 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 phrase 'long-running read operation' implies when to use it (for reads that take time), but it does not explicitly state when not to use it, mention alternatives like synchronous reads, or explain that results should be retrieved via get_async_task. The guidance is implied rather than explicit.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description's statement 'Report...risks' is consistent but adds no new behavioral traits beyond confirming it is a report. No side effects, authentication needs, or response details are disclosed.

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 with no unnecessary words. It effectively communicates the tool's purpose without redundancy.

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

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

Despite having an output schema, the description is too terse for a tool with 8 optional parameters. It does not explain how the parameters affect the risk report, what the output contains, or typical usage patterns, leaving gaps for an AI 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 100%, with each parameter having a clear description. The tool description does not elaborate on parameter usage or relationships, so it adds no value beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool reports Odoo upgrade and JSON-2 migration risks, specifying the resource and action. It distinguishes from siblings like 'analyze_upgrade_log' by focusing on a comprehensive risk report rather than log analysis, but could be more explicit about the scope.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'analyze_upgrade_log' or 'generate_json2_payload'. No context on prerequisites, typical use cases, or exclusions is 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's 'validate' is consistent. It adds minimal behavioral context beyond what annotations provide.

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

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

The description is a single concise sentence, but it is overly minimal given the tool's complexity and number of parameters. It could be better structured with more detail.

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

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

For a tool with 9 parameters and 0% schema coverage, the description is insufficient. Annotations help but do not provide enough context for 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?

With 0% schema description coverage and 9 parameters, the description fails to add meaning to any parameter. It does not compensate for 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 states the tool validates a standard write payload against optional metadata, which is clear and specific. However, it does not differentiate from siblings like execute_approved_write or preview_write.

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 validation use but lacks context or exclusion criteria.

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