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

No annotations are provided, so the description carries the full burden. It describes the tool's behavior (counting records) and the return value (number), but lacks details on permissions, rate limits, error handling, or whether it's read-only. The example adds some practical context, but more behavioral traits could be 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 appropriately sized and front-loaded with the core purpose, followed by structured sections for Args, Returns, and an Example. Every sentence earns its place by providing essential information without redundancy.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is mostly complete. It explains the purpose, parameters, and return value, and the output schema handles return details. However, it could benefit from more behavioral context like error cases or limitations.

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

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

The description adds significant meaning beyond the input schema, which has 0% coverage. It explains that 'model' is the Odoo model name and 'domain' is a search filter as an Odoo domain list, and provides an example illustrating their usage. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the tool's purpose with specific verb ('Count') and resource ('records matching a domain'), and distinguishes it from siblings like 'search_records' or 'get_record' by focusing on counting rather than retrieving data. The example further clarifies the counting function.

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

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

The description provides clear context for when to use this tool (to count records based on a model and domain filter), but does not explicitly mention when not to use it or name specific alternatives. It implies usage for counting rather than retrieving records, which helps differentiate from siblings.

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

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

With no annotations provided, the description carries full burden. It discloses the creation behavior and return format (success message with ID), but doesn't mention potential side effects, authentication requirements, error conditions, or rate limits. The description is adequate but lacks comprehensive behavioral context for a mutation tool.

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

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

The description is efficiently structured with clear sections (Args, Returns, Example) and zero wasted text. Every sentence adds value: the purpose statement, parameter explanations, return specification, and concrete example all serve distinct functions.

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 this is a mutation tool with no annotations but with output schema (implied by 'Returns' statement), the description provides good coverage: purpose, parameters, return values, and example. It could benefit from mentioning prerequisites or error handling, but the example compensates for some gaps.

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

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

With 0% schema description coverage, the description compensates well by explaining both parameters: 'model' as 'The Odoo model name' and 'values' as 'Dictionary of field values for the new record'. The example provides concrete syntax and format guidance beyond what the bare schema offers.

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

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

The description clearly states the specific action ('Create a new record') and resource ('in Odoo'), distinguishing it from sibling tools like update_record, delete_record, or get_record. It provides a concrete example that reinforces the purpose.

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

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

The description implies usage context through the example (creating a customer), but doesn't explicitly state when to use this tool versus alternatives like update_record for existing records or search_records for retrieval. It provides clear prerequisites (model and values) but lacks explicit exclusion guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is irreversible (a key behavioral trait) and mentions a success message return, but lacks details on error handling, authentication needs, or rate limits. This is adequate but has clear gaps for a destructive operation.

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

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

The description is appropriately sized and front-loaded with the core action, followed by structured sections for args and returns. The warning is placed effectively, but the 'Returns' section could be more concise (e.g., merging with the main text). Overall, it's efficient with minimal waste.

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 (destructive operation with 2 parameters) and no annotations, the description is moderately complete: it covers purpose, parameters, returns, and a critical warning. However, with an output schema present, the return value explanation is redundant, and it lacks context on permissions or error cases, leaving room for improvement.

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

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

Schema description coverage is 0%, so the description must compensate. It adds basic meaning for both parameters ('model' as Odoo model name, 'record_id' as ID to delete), which is helpful beyond the bare schema. However, it doesn't provide examples, constraints, or format details, keeping it at a baseline level.

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 ('Delete') and resource ('a record from Odoo'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'update_record' or 'create_record' beyond the action name, which prevents a perfect score.

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 like 'update_record' or 'create_record', nor does it mention prerequisites such as permissions or dependencies. The warning about irreversibility hints at caution but doesn't specify usage contexts or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds important context about permission requirements ('requires special permission in Odoo settings'), which is valuable. However, it doesn't describe potential side effects, error handling, or what types of methods might be destructive versus read-only, leaving gaps in behavioral understanding for a tool that can execute arbitrary code.

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

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

The description is well-structured and appropriately sized. It starts with the core purpose, lists parameters clearly, states the return value, adds a critical warning, and provides a concrete example. Every sentence earns its place with no redundant information, making it easy to scan and understand.

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

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

Given the tool's complexity (executing arbitrary methods with 5 parameters) and no annotations, the description does well by explaining parameters, providing an example, and noting permission requirements. The presence of an output schema means it doesn't need to explain return values. However, for such a powerful tool, more behavioral context about safety and limitations would be beneficial.

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 must compensate, which it does effectively by listing all 5 parameters with brief explanations. It clarifies that model and method are required, record_ids is optional, and args/kwargs are for method arguments. The example further illustrates how parameters work together, adding meaningful context beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Execute a custom method on an Odoo model.' It specifies the verb ('execute') and resource ('custom method on an Odoo model'), distinguishing it from sibling tools like create_record or update_record that perform specific operations rather than arbitrary method 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 provides clear context for when to use this tool: for executing custom methods on Odoo models, with an example showing a specific use case (confirming a sale order). However, it doesn't explicitly state when NOT to use it or name alternatives among siblings, though the example implies it's for actions beyond basic CRUD operations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the return format ('List of fields with their types and descriptions'), which adds some context, but lacks details on permissions, error handling, rate limits, or whether it's a read-only operation. For a tool with zero annotation coverage, this is insufficient to fully inform agent 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 appropriately sized and front-loaded, starting with a clear purpose statement. The 'Args' and 'Returns' sections are structured efficiently, with no wasted words. Every sentence adds value, making it easy to scan and understand quickly.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, but has an output schema), the description is partially complete. It covers the purpose and parameters well, and the output schema likely details return values, reducing the need for that in the description. However, it lacks behavioral context like error cases or usage scenarios, leaving gaps for an agent to operate effectively.

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

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

The description adds meaningful semantics beyond the input schema, which has 0% description coverage. It explains that 'model' is 'The Odoo model name' and 'field_types' is an 'Optional list of types to filter (e.g., ['many2one', 'char'])', including examples. This compensates well for the schema's lack of descriptions, though it doesn't cover all possible parameter nuances like format constraints.

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: 'Get field definitions for an Odoo model.' It specifies the verb ('Get') and resource ('field definitions for an Odoo model'), making the function understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_models' or 'get_record', which might also involve model metadata or retrieval, so it misses the highest score for sibling distinction.

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 doesn't mention scenarios like needing field metadata for validation, form building, or data mapping, nor does it reference sibling tools like 'list_models' (which might list models) or 'get_record' (which retrieves actual data). Without such context, users must infer usage from the purpose 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it retrieves data (implying read-only) and describes the return format, but lacks details on permissions, error handling, or rate limits. It adds some context but is incomplete for a tool with no 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 well-structured with sections for Args, Returns, and Example, making it easy to scan. It's appropriately sized, but the example could be more integrated; overall, it's efficient with minimal waste.

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

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

Given the tool's moderate complexity, no annotations, and an output schema present, the description does a good job covering basics like purpose, parameters, and return format. It lacks some behavioral details but is largely complete for a read operation with structured output.

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

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

The schema description coverage is 0%, so the description must compensate. It effectively explains all three parameters ('model', 'record_id', 'fields') with clear semantics and an example, adding significant value beyond the bare schema. However, it doesn't detail constraints like valid model names or field formats.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('record by ID'), making it easy to understand what it does. However, it doesn't explicitly differentiate from sibling tools like 'search_and_read_one' or 'get_record_name', which might also retrieve records 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?

The description provides no guidance on when to use this tool versus alternatives like 'search_and_read_one' or 'get_record_name'. It mentions an example but doesn't clarify prerequisites, exclusions, or specific contexts where this tool is preferred over siblings.

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

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

No annotations are provided, so the description carries the full burden. It states it's a read operation ('Get'), but doesn't disclose behavioral traits like authentication needs, error handling (e.g., what happens if the record doesn't exist), rate limits, or performance characteristics. The description is minimal and lacks essential operational context for a tool with parameters.

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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by structured Args and Returns sections. Every sentence earns its place, with no wasted words. However, the 'useful for looking up references' could be more integrated or omitted if not critical.

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 low complexity (2 parameters, no nested objects) and the presence of an output schema (which handles return values), the description is somewhat complete. However, with no annotations and minimal behavioral disclosure, it lacks context on permissions, errors, or usage scenarios. It's adequate but has clear gaps for a read operation in a system with multiple sibling tools.

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

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

The description adds basic semantics for the parameters: 'model: The Odoo model name' and 'record_id: The record ID', which clarifies what these inputs represent. However, with 0% schema description coverage, it doesn't fully compensate by explaining format constraints (e.g., valid model names, ID ranges) or examples. The baseline is 3 since it provides some meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Get the display name of a record' with a specific verb ('Get') and resource ('display name of a record'). It distinguishes itself from siblings like 'get_record' (which likely returns full record data) by focusing on just the display name. The 'useful for looking up references' adds context but doesn't fully differentiate from all siblings.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_record' (which might include the display name in full data) and 'search_and_read_one' (which might retrieve records with filtering), there's no explicit comparison or when/when-not guidance. The 'useful for looking up references' hints at context but doesn't specify alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns a list of models with permissions, which adds useful context about the output format. However, it doesn't mention behavioral traits like rate limits, authentication needs, or whether it's a read-only operation, leaving gaps in 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 front-loaded with the core purpose in the first sentence, followed by a concise note on the return value. Both sentences earn their place by providing essential information without any waste or redundancy, making it highly efficient.

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

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

Given the tool's low complexity (0 parameters, no annotations) and the presence of an output schema, the description is mostly complete. It explains the purpose and output format, but it could improve by adding more behavioral context, such as read-only nature or usage scenarios, to fully compensate for the lack of annotations.

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 schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it appropriately focuses on the tool's purpose and output. A baseline of 4 is applied for zero-parameter tools.

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

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

The description clearly states the specific action ('List all Odoo models') and resource ('available for MCP access'), distinguishing it from sibling tools like get_model_fields or search_records. It explicitly defines what the tool does without being vague or tautological.

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 by stating it lists models 'available for MCP access,' suggesting it's for discovering accessible models, but it doesn't explicitly guide when to use this tool versus alternatives like get_model_fields or search_records. No explicit when-not-to-use or alternative recommendations are provided.

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

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

No annotations are provided, so the description carries the full burden. It discloses that it returns the first matching record or a message if not found, which is useful behavioral context. However, it doesn't cover aspects like error handling, performance implications, or authentication needs, leaving gaps for a tool with mutation potential (searching and reading data).

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

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

The description is front-loaded with the core purpose, followed by structured sections for arguments and returns. Every sentence earns its place with no wasted words, making it highly efficient and 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 tool's moderate complexity (3 parameters, no annotations, but with an output schema), the description is reasonably complete. It covers purpose, parameters, and return behavior. The output schema likely details the return structure, so the description doesn't need to elaborate further, but it could benefit from more context on error cases or usage nuances.

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 lists the three parameters (model, domain, fields) and briefly explains their purposes, adding meaning beyond the bare schema. However, it doesn't provide details on format (e.g., Odoo domain syntax specifics) or examples, leaving some ambiguity.

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: 'Search and return the first matching record.' It specifies the verb (search and return) and resource (record), though it doesn't explicitly differentiate from sibling tools like 'search_records' or 'get_record' beyond calling itself a 'convenience method.'

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 by stating it's a 'convenience method' for retrieving the first match, but it doesn't explicitly say when to use this versus alternatives like 'search_records' (which might return multiple records) or 'get_record' (which might require a specific ID). No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the search functionality and return format ('JSON list of matching records'), but doesn't mention important behavioral aspects like authentication requirements, rate limits, error handling, or whether this is a read-only operation (though 'search' implies it likely is). The examples help but don't fully compensate for missing behavioral context.

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

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

The description is well-structured with clear sections (Args, Returns, Examples) and every sentence adds value. It's appropriately sized for a 6-parameter tool with complex domain syntax. The information is front-loaded with the core purpose first, followed by detailed parameter explanations and practical examples.

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 (6 parameters, 0% schema coverage, no annotations) and the presence of an output schema, the description is quite complete. It thoroughly documents all parameters and provides helpful examples. The main gap is the lack of behavioral context and usage guidelines compared to sibling tools. The output schema handles return values, so the description doesn't need to explain those.

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

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

Schema description coverage is 0%, so the description must fully document parameters. It provides excellent parameter semantics: each of the 6 parameters is clearly explained with examples, default values, and format expectations. The domain parameter explanation includes common operators, and the fields parameter clarifies that empty means 'smart defaults'. This goes well beyond what the bare schema provides.

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

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

The description clearly states 'Search for records in an Odoo model' which is a specific verb+resource combination. It doesn't explicitly differentiate from siblings like 'search_and_read_one' or 'get_record', but the purpose is unambiguous. The title is null, so the description carries the full burden of explaining the tool's function.

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 like 'search_and_read_one', 'get_record', or 'count_records'. It explains what the tool does but offers no context about appropriate use cases, prerequisites, or comparisons with sibling tools. The examples show how to use it but not when to choose it over other options.

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

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

No annotations are provided, so the description carries full burden. It states 'Update' implying mutation but doesn't disclose behavioral traits like required permissions, whether changes are reversible, error handling, or rate limits. The example adds minimal context but lacks comprehensive behavioral details needed for a mutation tool.

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

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

The description is well-structured and front-loaded with the core purpose, followed by Args, Returns, and Example sections. Every sentence earns its place, with no redundant information, making it efficient and 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 complexity (mutation tool with 3 params, nested objects, no annotations) and an output schema (implied by 'Returns'), the description is moderately complete. It covers parameters and includes an example but lacks behavioral context and usage guidelines, leaving gaps for safe and effective tool invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for all three parameters ('model', 'record_id', 'values') in the Args section and reinforces with an example, adding meaningful context beyond the bare schema. However, it doesn't detail constraints like valid model names or value formats.

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

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

The description clearly states the action ('Update') and target ('an existing record in Odoo'), providing specific verb+resource. However, it doesn't explicitly differentiate from siblings like 'create_record' or 'delete_record' beyond the 'existing' qualifier, which is implied but not contrasted directly.

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 like 'create_record' or 'delete_record'. It mentions 'existing record' but doesn't specify prerequisites, exclusions, or contextual triggers for choosing this over other mutation tools in the sibling list.

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