MCP Odoo Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v2.0.0
Disambiguation4/5
Most tools have distinct purposes targeting specific resources and actions, such as expense management, leave allocation, and contact handling. However, some overlap exists between 'list_expenses' and 'list_expense_reports' which could cause confusion, and 'search_records' is a generic tool that might overlap with specific list tools, though descriptions help clarify boundaries.
Naming Consistency5/5
Tool names follow a highly consistent verb_noun pattern throughout, such as 'create_contact', 'list_employees', 'update_expense', and 'delete_timesheet'. All tools use snake_case uniformly, with clear and predictable naming that enhances readability and agent usability.
Tool Count3/5
With 38 tools, the count is borderline high for a single server, potentially overwhelming for agents. While Odoo is a comprehensive ERP system, the tool set covers multiple domains (e.g., HR, sales, expenses), which might be better split into focused servers. However, the tools are well-scoped within their domains, avoiding redundancy.
Completeness4/5
The tool set provides extensive coverage across Odoo modules, including CRUD operations for key resources like contacts, expenses, timesheets, and leave allocations. Minor gaps exist, such as missing update/delete for some resources like contacts or invoices, but agents can work around these with existing tools like 'search_records' or by leveraging state-based operations.
Average 3.3/5 across 38 of 38 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
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 this is a read operation ('Get details'), implying it's likely safe and non-destructive, but doesn't mention potential errors (e.g., invalid ID), authentication needs, rate limits, or response format details. This leaves significant gaps for an agent to understand the tool's behavior fully.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the core purpose stated first in a clear sentence. The Args and Returns sections are structured but could be more concise by integrating them into the main text, as they add minimal value beyond the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (single parameter) and the presence of an output schema (which handles return values), the description is minimally adequate. However, it lacks context about behavioral traits (e.g., error handling) and usage guidelines, making it incomplete for optimal agent understanding despite the structured support.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explicitly documents the single parameter ('contact_id: Contact ID'), which adds meaning beyond the input schema's 0% description coverage. However, it doesn't elaborate on format constraints (e.g., integer range) or provide examples, so it only partially compensates for the schema's lack of detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 ('details of a specific contact'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'list_contacts' or 'create_contact', which would require explicit comparison for 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.
Usage Guidelines2/5
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 'list_contacts' for browsing or 'create_contact' for adding new contacts. It lacks context about prerequisites, such as needing a valid contact_id, or exclusions for when other tools might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions pagination (limit/offset) and optional filtering, but doesn't address important aspects like authentication requirements, rate limits, error conditions, or whether this is a read-only operation. For a list tool with 5 parameters, more behavioral context is needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and uses bullet-point style formatting. Each sentence adds value - the opening statement establishes purpose, and parameter descriptions are efficient. It could be slightly more concise by combining some parameter explanations, but overall it's appropriately sized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with 5 parameters and no annotations, the description covers the basic purpose and parameters adequately. However, it lacks important context about authentication, error handling, and usage scenarios. The presence of an output schema means it doesn't need to explain return values, but more behavioral context would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides clear documentation for all 5 parameters including their optional nature, default values, and specific details like the state enum values (draft, confirm, validate, refuse). Since schema description coverage is 0%, the description fully compensates by explaining each parameter's purpose and constraints beyond what the bare schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List leave allocations' which clearly indicates the verb (list) and resource (leave allocations). However, it doesn't distinguish this from other list operations on the server (like list_employees, list_leave_types) beyond the resource type. The purpose is clear but lacks sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. The server has multiple list tools (e.g., list_employees, list_leave_types) but no indication of which to choose for different scenarios. There's also no mention of prerequisites or when this tool would be inappropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states this is a list operation, implying it's likely read-only, but doesn't confirm safety aspects like whether it requires authentication, has rate limits, or affects system state. The description mentions pagination via 'limit' and 'offset' but doesn't explain how results are ordered or if there are performance considerations for large datasets.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with a clear purpose statement followed by parameter explanations, but it's somewhat verbose with repetitive formatting. Sentences like 'List sale orders (quotations/orders).' are efficient, but the Args/Returns sections could be more streamlined. It avoids fluff but isn't optimally concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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, no annotations, but with an output schema), the description is moderately complete. It explains parameters well and notes the return type ('List of orders'), but lacks behavioral context like error handling, authentication needs, or performance limits. The output schema existence reduces the need to detail return values, but more operational guidance would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the input schema, which has 0% description coverage. It explains each parameter's purpose: 'state' with its mapping to order types, 'partner_id' as a customer filter, date parameters for ranges, and 'limit'/'offset' for pagination with defaults. This compensates well for the schema's lack of descriptions, though it doesn't cover format details like date validation or state enum constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'List sale orders (quotations/orders).' It specifies the verb ('List') and resource ('sale orders'), with helpful clarification about what constitutes a sale order ('quotations/orders'). However, it doesn't explicitly differentiate this tool from sibling tools like 'get_sale_order' or 'search_records,' which would be needed for 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.
Usage Guidelines2/5
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 sibling tools like 'get_sale_order' (for retrieving a single order) or 'search_records' (which might offer different filtering capabilities). There's no context about prerequisites, appropriate scenarios, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 'Add an attachment' and mentions a return 'Confirmation with created attachment ID', which implies a write operation with a response. However, it lacks details on permissions, error handling, file size limits, or side effects (e.g., if the attachment overwrites existing ones). This leaves significant gaps for a mutation tool, scoring 2 for partial but insufficient transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, starting with the core action. The Args and Returns sections are structured clearly, with no wasted sentences. However, the formatting includes extra quotes and indentation that slightly reduce readability, and it could be more streamlined (e.g., combining lines). Overall, it's efficient but not perfect, scoring 4.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (mutation with 3 parameters), no annotations, and an output schema (implied by Returns section), the description is moderately complete. It covers the action, parameters, and return value, but lacks behavioral context like error cases or system constraints. With output schema handling return values, the description meets minimum viability but has clear gaps, scoring 3.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 'expense_id' is the 'Expense ID', 'file_path' is the 'Absolute path to file to attach', and 'filename' is 'optional, uses original filename by default'. This clarifies purpose and defaults, compensating well for the schema gap. With 3 parameters and low schema coverage, the description provides good value, though it could detail formats (e.g., integer for ID), earning a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Add' and resource 'attachment to an existing expense', making the purpose specific and understandable. It distinguishes from siblings like 'create_expense' or 'list_expense_attachments' by focusing on attachment addition rather than creation or listing. However, it doesn't explicitly contrast with all possible alternatives, keeping it at 4 instead of 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites (e.g., expense must exist), exclusions (e.g., not for creating expenses), or compare to siblings like 'list_expense_attachments'. Usage is implied through the action but lacks explicit context, scoring 2 for minimal guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool retrieves product details but doesn't cover important aspects like whether it's a read-only operation, authentication requirements, error handling, or rate limits. The description is minimal and lacks 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and well-structured, with a clear purpose statement followed by brief sections for arguments and returns. Every sentence serves a purpose without unnecessary elaboration, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter) and the presence of an output schema, the description is minimally adequate. However, with no annotations and 0% schema description coverage, it lacks details on behavioral traits and parameter nuances, leaving gaps in understanding how to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal parameter semantics by naming 'product_id' and stating it's for a 'specific product', but schema description coverage is 0%, so the schema provides no additional details. The description doesn't explain the parameter's format, constraints, or examples, offering only basic context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 details') and resource ('specific product'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'list_products', which retrieves multiple products rather than a single one.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 sibling tools like 'list_products' for browsing multiple products or clarify prerequisites such as needing a valid product ID. Usage context is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states it's a 'Get' operation, implying read-only, but doesn't cover aspects like authentication needs, rate limits, error handling, or data freshness. For a tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
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. There's minimal waste, though the formatting with quotes and indentation slightly reduces readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 output schema), the description is partially complete. It covers purpose and parameters well, but lacks usage guidelines and behavioral context. The output schema existence means return values don't need explanation, but overall gaps remain for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful semantics beyond the input schema: it specifies the date format (YYYY-MM-DD) and clarifies that parameters are optional, which the schema only implies through defaults and null types. With 0% schema description coverage, this compensates well for the two parameters, though it could detail default behaviors or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('total costs per R&D project from analytic accounts'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_projects' or 'get_timesheet_summary_by_employee', which might also involve project-related data, so it misses full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites, context for R&D projects, or compare to other cost-related or project-related tools in the sibling list, leaving the agent with no usage direction beyond the basic purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 what the tool does (get a summary) and the return format, but lacks critical behavioral details such as whether this is a read-only operation, any authentication requirements, rate limits, pagination behavior, or error conditions. For a tool with no annotations, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and well-structured with clear sections for Args and Returns. It uses bullet points for parameters and avoids unnecessary verbosity. Every sentence earns its place by providing essential information about parameters and return values.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there's an output schema (which covers return values), the description doesn't need to explain return details. However, with no annotations and a 0% schema description coverage, the description compensates well for parameters but lacks behavioral context (e.g., safety, performance). It's adequate for a read operation but could be more complete regarding usage constraints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 adds meaningful semantics for all three parameters: 'date_from' and 'date_to' are explained as start and end dates with format YYYY-MM-DD, and 'expected_hours_per_day' is described with its default value and purpose. This fully documents the parameters beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 a summary of hours logged by employee for a given period.' It specifies the verb ('Get'), resource ('summary of hours logged by employee'), and scope ('for a given period'). However, it doesn't explicitly differentiate from sibling tools like 'list_timesheets' or 'get_timesheet' (if those exist), which would require a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 sibling tools like 'list_timesheets' or explain scenarios where this summary tool is preferred over raw timesheet listings. The only implied usage is for summarizing hours by employee, but no explicit alternatives or exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions filtering by department and pagination (limit/offset), which adds some behavioral context beyond basic listing. However, it lacks critical details: whether this is a read-only operation, what permissions are required, how results are formatted, if there are rate limits, or if it's destructive. For a tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the core purpose in the first sentence. The Args/Returns sections are structured clearly, though slightly verbose with defaults repeated from the schema. Every sentence adds value, but minor trimming could improve efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (list operation), 3 parameters with 0% schema coverage, no annotations, and an output schema (which handles return values), the description is adequate but has gaps. It covers parameters well but lacks behavioral context like authentication needs or result format details. With output schema present, it doesn't need to explain returns, but overall completeness is minimal viable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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% schema description coverage. It explains that 'department_id' filters by department, 'limit' sets the maximum number (with default 50), and 'offset' handles pagination (default 0). This compensates well for the schema's lack of descriptions, though it doesn't detail data types or constraints like integer/null for department_id.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('employees in Odoo'), making the purpose immediately understandable. It distinguishes from siblings like 'get_employee' (singular) and 'list_departments' (different resource), though it doesn't explicitly contrast them. The purpose is specific but lacks explicit sibling differentiation for 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.
Usage Guidelines2/5
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 doesn't mention when to use 'list_employees' over 'get_employee' (for a single employee) or 'search_records' (for more complex queries), nor does it specify prerequisites like authentication or context. The description offers no usage context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 tool lists attachments but doesn't describe key behaviors: whether it's read-only (implied but not explicit), how it handles invalid expense_ids, if results are paginated, or any rate limits. For a tool with zero annotation coverage, this is a significant gap 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.
Conciseness4/5
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 structured Args and Returns sections. It avoids unnecessary fluff and uses clear formatting. The only minor inefficiency is the lack of integration between the prose and structured parts, but overall it's appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is minimally adequate. However, it lacks context about behavioral traits (e.g., error handling) and usage guidelines, which are important even for simple tools. The output schema reduces the burden, but more completeness would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter 'expense_id', explaining it's the ID of the expense whose attachments are listed. With 0% schema description coverage (schema only provides title and type), this compensates well by clarifying the parameter's role. However, it doesn't specify format constraints (e.g., integer range) or provide examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'attachments for an expense', making the purpose immediately understandable. It distinguishes itself from siblings like 'add_expense_attachment' by focusing on retrieval rather than creation. However, it doesn't explicitly differentiate from other list tools (e.g., 'list_expenses'), leaving some ambiguity about scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites (e.g., needing a valid expense_id), compare it to similar tools like 'list_expenses', or specify use cases (e.g., reviewing attachments before approval). This lack of context leaves the agent to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions pagination via 'limit' and 'offset' and filtering by 'project_id', but lacks details on permissions, rate limits, error handling, or whether it's read-only (implied by 'List' but not explicit). This leaves significant gaps for a tool with no 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections for Args and Returns, using bullet-like formatting. It's front-loaded with the core purpose and avoids unnecessary details, though the 'Returns' section could be more concise by relying on the output schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, but an output schema exists, the description is moderately complete. It covers parameters and return format basics, but lacks behavioral context like auth needs or error cases. The output schema reduces the need for return value details, but more guidance on usage and transparency would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for all three parameters: 'project_id' is described as optional for filtering, 'limit' specifies a default and maximum number, and 'offset' explains pagination. Since schema description coverage is 0%, this compensates well, though it doesn't detail data types or constraints beyond defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('available tasks in Odoo'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'list_projects' or 'list_timesheets' beyond the resource type, 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.
Usage Guidelines2/5
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 sibling tools like 'search_records' for more complex queries or 'list_projects' for related data, nor does it specify prerequisites or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool updates an entry but doesn't cover critical aspects like required permissions, whether updates are reversible, error handling, or rate limits. The mention of 'Update confirmation' in returns is minimal and doesn't detail the response format 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the main purpose, followed by structured Arg and Return sections. Each sentence earns its place by providing essential information without redundancy, though it could be slightly more concise by integrating the format details into the parameter list more seamlessly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a mutation tool with no annotations and an output schema present, the description is moderately complete. It covers the basic purpose and parameters but lacks behavioral context and usage guidelines. The output schema likely handles return value details, so the description's minimal return statement is acceptable, but overall gaps remain for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics by explaining each parameter's purpose and format (e.g., 'date_entry: New date in YYYY-MM-DD format'), which goes beyond the schema's basic titles. However, it doesn't cover constraints like valid hour ranges or description length limits.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Update an existing timesheet entry,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'update_expense' or 'create_timesheet,' though the context is reasonably clear from the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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_timesheet' or 'delete_timesheet.' It lacks context about prerequisites, such as needing an existing timesheet entry, and doesn't mention any exclusions or best practices for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 state change and returns a confirmation message, but fails to detail critical aspects like required permissions, whether the action is reversible, error conditions, or side effects. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by brief sections for Args and Returns. Each sentence earns its place without redundancy, making it efficient and easy to parse. The structure is clear and minimalistic.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with 1 parameter) and the presence of an output schema (which handles return values), the description is moderately complete. It covers the basic action and parameter semantics but lacks behavioral details like permissions or error handling. With no annotations and an output schema, it meets a minimum viable level but has clear gaps for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that 'allocation_id' is the 'Allocation ID to approve', clarifying its role beyond the schema's basic type (integer). However, it doesn't provide format details or examples, and with only 1 parameter, the baseline is high. The description adequately covers the parameter's purpose but could be more detailed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('approve') and resource ('leave allocation'), and specifies the state transition ('from draft/confirm to validate'). It distinguishes this from sibling tools like 'create_leave_allocation' or 'list_leave_allocations' by focusing on approval rather than creation or listing. However, it doesn't explicitly contrast with other approval-related tools if they existed, keeping it at 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance on when to use this tool—it implies usage for approving leave allocations in specific states (draft/confirm). However, it lacks explicit context on prerequisites (e.g., permissions needed), alternatives (e.g., other tools for rejection or editing), or exclusions (e.g., when not to use it). No sibling tools are directly referenced for comparison, resulting in limited guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool creates a report and returns a confirmation with an ID, but lacks critical details: whether this is a mutation (implied by 'create'), what permissions are required, if it's idempotent, error conditions (e.g., invalid expense IDs), or side effects (e.g., report status changes). For a creation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise, with zero wasted text. It front-loads the core purpose in one sentence, followed by clear Arg/Return sections. Every sentence earns its place by directly contributing to understanding the tool's function and parameters, making it easy to scan and comprehend quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a creation operation with 2 parameters), lack of annotations, and presence of an output schema (which handles return values), the description is minimally adequate. It covers the basic purpose and parameters but misses behavioral context (e.g., mutation effects, error handling) and usage guidelines. The output schema likely details the confirmation structure, so the description doesn't need to elaborate on returns, but overall completeness is limited to the essentials.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 'name' is the 'Report name/title' and 'expense_ids' is a 'List of expense IDs to include in the report,' clarifying their roles in report creation. However, it doesn't detail constraints (e.g., name length, valid ID sources) or provide examples, preventing a perfect score. With 2 parameters and no schema descriptions, this compensation is adequate but not comprehensive.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Create an expense report from selected expenses.' It specifies the verb ('create') and resource ('expense report'), and distinguishes it from siblings like 'create_expense' (which creates individual expenses) or 'submit_expense_report' (which submits an existing report). However, it doesn't explicitly contrast with 'list_expense_reports' (which lists reports) or other report-related tools, keeping it from 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.
Usage Guidelines2/5
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 prerequisites (e.g., needing existing expenses via 'list_expenses'), exclusions (e.g., not for editing reports), or comparisons to siblings like 'submit_expense_report' (for submitting after creation). The agent must infer usage from context alone, which is insufficient for effective tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the tool creates an entry and returns a confirmation with ID, but doesn't disclose permissions needed, whether it's idempotent, error conditions, or side effects. The return statement is helpful but insufficient 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement followed by parameter details and return information. Every sentence earns its place, and it's front-loaded with the core functionality. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 5-parameter mutation tool with no annotations, the description is moderately complete. It explains parameters well and mentions the return value, but lacks behavioral context like permissions or error handling. The output schema exists, so detailed return explanation isn't needed, but other gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description compensates well by explaining all 5 parameters in the Args section. It clarifies optional/default values (task_id optional, date_entry defaults to today) and formats (YYYY-MM-DD). This adds significant meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Create a new timesheet entry.' It specifies the verb ('create') and resource ('timesheet entry'), making the action unambiguous. However, it doesn't differentiate from sibling tools like 'update_timesheet' or 'delete_timesheet' beyond the basic verb difference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites (e.g., needing valid project IDs), exclusions, or comparisons to sibling tools like 'update_timesheet' or 'list_timesheets'. Usage is implied by the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. 'Delete' implies a destructive mutation, but the description doesn't disclose whether this requires specific permissions, if deletion is permanent/reversible, what happens to associated records, or any rate limits. The mention of 'Deletion confirmation' in Returns hints at output but lacks detail. For a destructive operation with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement followed by Args and Returns sections. Every sentence earns its place: the first states the action, and the subsequent lines provide essential parameter and return context without redundancy. It's appropriately sized for a single-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (destructive mutation), lack of annotations, and presence of an output schema (which should cover return values), the description is minimally adequate. It covers the basic action and parameter but misses critical behavioral details like permissions, permanence, and error handling. The output schema existence reduces the need to explain returns, but overall completeness is borderline.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter: 'timesheet_id: ID of entry to delete' clarifies that this identifies the specific timesheet to delete. With schema description coverage at 0% (the schema only provides title and type), this compensates well. However, it doesn't specify format constraints (e.g., valid ID ranges) or where to obtain the ID, leaving minor gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 'timesheet entry', making the purpose immediately understandable. It distinguishes itself from sibling tools like 'update_timesheet' by specifying deletion rather than modification. However, it doesn't explicitly differentiate from 'delete_expense', which is a similar deletion operation on a different resource.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites (e.g., needing an existing timesheet), when deletion is appropriate versus updating, or what happens to related data. With sibling tools like 'update_timesheet' and 'list_timesheets' available, this lack of contextual guidance is a significant gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It implies a read operation ('Get details') but doesn't disclose authentication needs, rate limits, error conditions, or what 'Complete employee details' entails beyond the output schema. This is inadequate for a tool with behavioral implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement followed by Args and Returns sections, using minimal sentences that each add value. There's no redundant information, and it's front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (single parameter) and the presence of an output schema (which handles return values), the description is moderately complete. However, it lacks context on permissions, error handling, or sibling tool differentiation, which are gaps for a read operation in a system with many related tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter by specifying 'Employee ID' in the Args section, which clarifies its purpose beyond the schema's generic 'Employee Id' title. With 0% schema description coverage and only one parameter, this adequately compensates, though it could detail format or validation rules.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 ('employee'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'list_employees' or 'get_contact', which would require more specificity about scope or data granularity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'list_employees' for multiple records or 'get_contact' for related data. There's no mention of prerequisites, context, or exclusions, leaving usage decisions entirely to the agent's inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool retrieves details but doesn't mention whether it's a read-only operation, requires authentication, has rate limits, or what happens if the invoice doesn't exist. The description is minimal and lacks critical behavioral context for a tool with no 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and well-structured: a clear purpose statement followed by Args and Returns sections. Every sentence earns its place, with no redundant information. It's front-loaded with the main functionality, 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.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and incomplete parameter documentation (0% schema coverage), it should provide more behavioral context. The description covers the basics but lacks depth for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter: 'invoice_id: Invoice ID'. Since schema description coverage is 0% (the schema only provides a title and type), this compensates by explaining what the parameter represents. However, it doesn't specify format constraints or examples, leaving some gaps. With 0 parameters documented in the schema, the baseline is 4, and the description meets this by providing basic semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 details of a specific invoice with its lines.' It specifies the verb ('Get') and resource ('invoice'), and distinguishes it from sibling tools like 'list_invoices' by focusing on a single invoice. However, it doesn't explicitly differentiate from other 'get_' tools like 'get_contact' or 'get_employee' beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 when to use 'get_invoice' instead of 'list_invoices' or other retrieval tools, nor does it specify prerequisites or exclusions. The context is implied (retrieving a single invoice), but no explicit usage instructions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It states it 'Get details' but doesn't clarify if this is a read-only operation, requires specific permissions, has rate limits, or what happens if the order_id is invalid. For a tool with zero annotation coverage, this lacks critical behavioral context, though it doesn't contradict anything.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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 clear sections for Args and Returns. It uses minimal words without redundancy, making it efficient and easy to parse. Every sentence adds value, with no wasted content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter) and the presence of an output schema (which handles return values), the description is moderately complete. It covers the basic purpose and parameter semantics but lacks usage guidelines and behavioral details, which are gaps for a tool with no annotations. It's adequate but not fully comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter 'order_id' by specifying it's for retrieving details of a sale order, which clarifies its role beyond the schema's basic type (integer). With 0% schema description coverage and only one parameter, this adequately compensates, though it could specify format or source (e.g., from list_sale_orders).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('details of a sale order with its lines'), making the purpose specific and understandable. It distinguishes from siblings like 'list_sale_orders' by focusing on a single order's details rather than listing multiple orders. However, it doesn't explicitly contrast with 'get_invoice' or other get_* tools, which slightly limits differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites (e.g., needing an order_id from list_sale_orders), exclusions, or comparisons to similar tools like get_invoice. This leaves the agent without context for tool selection beyond the basic purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 pagination via 'limit' and 'offset' but does not cover critical aspects like rate limits, authentication needs, error handling, or whether the list is read-only or mutable. This leaves significant gaps for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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 Args and Returns. Every sentence earns its place with no wasted words, 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.
Completeness3/5
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 moderately complete. However, it lacks behavioral context and usage guidelines, which are important for a tool with no annotations, leaving room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful semantics beyond the input schema by explaining that 'limit' is the 'Maximum number (default: 50)' and 'offset' is for 'pagination (default: 0)', which clarifies their roles. Since schema description coverage is 0%, this compensates well, though it could detail constraints like min/max values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('departments in Odoo'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'list_contacts' or 'list_employees', which follow a similar pattern, so it misses full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'search_records' for filtered queries or other list tools for different resources. It lacks explicit context, prerequisites, or exclusions, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions pagination via 'limit' and 'offset' and filtering by 'year', which adds some context. However, it lacks details on permissions, rate limits, error handling, or whether the operation is read-only (implied by 'List' but not confirmed). This is inadequate for a tool with multiple parameters and no 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, starting with the core purpose followed by parameter details. Every sentence earns its place by clarifying inputs and outputs. It could be slightly more concise by integrating parameter explanations more seamlessly, but overall it's efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (4 parameters, no annotations, but with an output schema), the description is fairly complete. It covers the purpose, parameters, and return value ('List of public holidays'). The output schema handles return details, so the description doesn't need to explain those. However, it lacks behavioral context like error cases or usage scenarios, which holds it back from a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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% description coverage. It explains each parameter's purpose: 'calendar_id' as 'Working calendar ID', 'year' for filtering, 'limit' for maximum entries, and 'offset' for pagination. This compensates well for the schema's lack of descriptions, though it doesn't detail data formats or constraints (e.g., valid year ranges).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'List public holidays (global time off) from a working calendar.' It specifies the verb ('List'), resource ('public holidays'), and source ('working calendar'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'list_leave_allocations' or 'list_leave_types', 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.
Usage Guidelines2/5
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 sibling tools like 'create_public_holiday' for adding holidays or other list tools for different data types. Usage is implied by the name and purpose but not explicitly stated, leaving gaps for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the tool submits for approval, implying a mutation that changes state and may trigger workflows, but doesn't disclose behavioral traits like required permissions, whether submission is reversible, expected response time, or error conditions. For a mutation tool with zero annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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 structured Args and Returns sections. Every sentence earns its place: the purpose statement is essential, and the parameter and return explanations add value without redundancy. It's appropriately sized for a single-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with one parameter), no annotations, but an output schema exists (so return values are documented elsewhere), the description is minimally adequate. It covers the basic action and parameter, but lacks behavioral context and usage guidelines, leaving gaps that reduce completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by explaining the single parameter ('report_id: ID of the expense report to submit'), adding meaning beyond the schema's basic type. With only one parameter, this is sufficient to earn a 4, though it doesn't detail format constraints (e.g., numeric range).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('submit') and resource ('expense report'), specifying it's 'for approval'. It distinguishes from siblings like 'create_expense_report' (creation vs. submission) and 'list_expense_reports' (listing vs. submission). However, it doesn't explicitly contrast with all potential alternatives, keeping it at 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites (e.g., that the report must exist via 'create_expense_report' first), exclusions, or contextual triggers. With siblings like 'create_expense_report' and 'list_expense_reports', this lack of differentiation is a significant gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 that the tool 'Returns: Connection and user information,' which gives some insight into output, but lacks details on error handling, authentication needs, rate limits, or whether it's read-only or has side effects. For a tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, with two sentences that directly state the purpose and return value. It is front-loaded with the main action and wastes no words, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no annotations, but has an output schema), the description is minimally adequate. It states the purpose and return information, but with no annotations, it should ideally provide more behavioral context (e.g., side effects, error cases). The output schema existence reduces the need to detail return values, but overall completeness is just acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it appropriately avoids discussing any. A baseline of 4 is assigned as it handles the lack of parameters correctly without unnecessary information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Test the connection to Odoo.' This specifies the verb ('Test') and resource ('connection to Odoo'), making it understandable. However, it doesn't explicitly differentiate from sibling tools, as there are no other connection-testing tools in the list, so a 4 is appropriate rather than a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites, timing, or context for usage, such as whether it's for initial setup, troubleshooting, or periodic checks. This leaves the agent without clear usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 tool creates an expense and returns a confirmation with an ID, which implies a write operation. However, it lacks critical behavioral details: it doesn't mention permissions required, whether the expense is automatically submitted or saved as draft, potential side effects (e.g., notifications), or error conditions (e.g., invalid product_id).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, args, returns) and uses bullet-like formatting for parameters. It's appropriately sized—each sentence adds value, such as explaining parameter meanings and referencing other tools. A slight deduction because the 'Args:' and 'Returns:' labels are somewhat redundant given the structured format, but overall it's efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a write operation with 6 parameters) and no annotations, the description is moderately complete. It covers parameter semantics thoroughly and mentions an output schema exists ('Returns: Confirmation with created expense ID'), so it doesn't need to detail return values. However, it lacks behavioral context like permissions or side effects, which is a gap for a creation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant semantic value beyond the input schema, which has 0% description coverage. It clearly explains each parameter's purpose (e.g., 'Expense name/title' for name, 'Expense category ID (see list_expense_categories)' for product_id), provides format details ('YYYY-MM-DD' for date_expense), and indicates defaults and optionality. 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Create a new expense report.' It specifies the verb ('create') and resource ('expense report'), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'create_expense_report' or 'update_expense', which would be needed for 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.
Usage Guidelines2/5
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 sibling tools like 'create_expense_report' (which might be for multi-expense reports) or 'update_expense' (for modifications), nor does it specify prerequisites or contextual constraints for creating an expense.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions pagination via limit/offset and filtering options, but lacks critical details like whether this is a read-only operation, what permissions are required, rate limits, or what specific information is returned in the 'List of contacts with their information'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and uses minimal but effective language. Every sentence serves a purpose, though the opening line could be slightly more specific about what 'list' entails (e.g., 'Retrieve and filter contacts').
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (5 parameters, filtering logic) and the presence of an output schema (which handles return value documentation), the description is reasonably complete. However, it lacks behavioral context that would be important for safe operation, especially with no annotations to provide safety hints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics beyond the schema, which has 0% description coverage. It explains each parameter's purpose (e.g., 'Filter customers (True/False/None for all)'), clarifies default values, and documents the meaning of null values for boolean filters. 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('contacts (partners) in Odoo'), making the purpose immediately understandable. It distinguishes from siblings like 'get_contact' (singular retrieval) and 'create_contact' (creation), though it doesn't explicitly mention these distinctions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 sibling tools like 'search_records' that might offer different filtering capabilities, nor does it specify prerequisites or contexts where this tool is preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions pagination via limit/offset and the return format, which adds some context, but it doesn't cover important aspects like authentication needs, rate limits, error handling, or whether the operation is read-only or has side effects. For a list tool with zero annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise, with a clear purpose statement followed by Args and Returns sections. Every sentence adds value without redundancy, making it easy to parse and front-loaded with essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 value details), the description is reasonably complete. It covers the purpose, parameters, and return overview, but could improve by adding usage context or behavioral details 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.
Parameters4/5
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 'limit' is the 'Maximum number (default: 50)' and 'offset' is for 'Offset for pagination (default: 0)', clarifying their roles and defaults. This compensates well for the lack of schema descriptions, though it doesn't detail constraints like valid ranges.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and resource 'available leave types in Odoo', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_leave_allocations' or 'list_public_holidays', which are related but distinct list operations in the same domain.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites, context for use, or how it differs from other list tools in the sibling set, such as 'list_leave_allocations' for leave allocations or 'list_public_holidays' for holidays.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers limited behavioral insight. It mentions 'partial match with ilike' for the value parameter, which adds some context on search behavior. However, it doesn't disclose critical traits like whether this is a read-only operation, potential rate limits, authentication requirements, error handling, or what happens with invalid models/fields. For a search tool with 5 parameters and no annotations, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement followed by Args and Returns sections. It's appropriately sized—each sentence adds value, such as explaining the partial match behavior. Minor improvements could include briefer formatting, but it's efficient and front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, no annotations, but has an output schema), the description is partially complete. It covers parameter semantics well and mentions return values, but lacks behavioral context like safety, performance, or error handling. The output schema likely details the return structure, so the description doesn't need to elaborate on that, but overall it's adequate with clear gaps in usage and transparency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant semantic value beyond the input schema, which has 0% description coverage. It explains each parameter: 'model' as technical model name with examples, 'field' as the field to search on, 'value' with partial match behavior, and 'limit'/'offset' with defaults and pagination context. This fully compensates for the schema's lack of descriptions, making parameters clear and actionable.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches records in Odoo models with a specific verb ('Search') and resource ('records in any Odoo model'). It distinguishes from siblings like 'get_contact' or 'list_contacts' by being a generic search across any model rather than fetching specific entity types. However, it doesn't explicitly contrast with other search-like siblings (none are present in the list).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites (e.g., authentication), when not to use it (e.g., for simple lookups by ID), or compare it to sibling tools like 'get_contact' for specific entity retrieval. Usage is implied by the generic search capability but lacks explicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. While it states the tool creates a contact and returns a confirmation with ID, it lacks critical behavioral details: whether this requires specific permissions, if it's idempotent, what happens on duplicate contacts, error conditions, or rate limits. The description covers basic functionality but misses important operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections for Args and Returns, making it easy to parse. It's appropriately sized for a tool with many parameters, though the introductory sentence is minimal. Every sentence adds value, with no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (10 parameters, 1 required) and the presence of an output schema (implied by 'Returns'), the description is reasonably complete. It documents all parameters thoroughly and states the return value. However, without annotations, it could better address behavioral aspects like error handling or side effects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds substantial value beyond the input schema, which has 0% description coverage. It provides clear semantics for all 10 parameters, explaining what each represents (e.g., 'Contact name', 'True if it's a company'), noting optionality, and specifying defaults (e.g., 'default: True' for customer). 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Create a new contact.' It uses a specific verb ('create') and identifies the resource ('contact'), making the action unambiguous. However, it doesn't differentiate from sibling tools like 'get_contact' or 'list_contacts' beyond the obvious create vs. read distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites (e.g., authentication), when not to use it, or how it relates to sibling tools like 'get_contact' or 'list_contacts' for contact management workflows.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. While it mentions pagination through limit/offset parameters and date filtering, it doesn't describe important behavioral aspects like whether this is a read-only operation, what permissions are required, whether results are sorted, or if there are rate limits. The description provides basic functional information but lacks crucial operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections for purpose, arguments, and returns. Each sentence serves a specific purpose with no wasted words. The parameter explanations are efficient yet complete. The only minor improvement would be front-loading the most critical information more prominently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there's an output schema (though not shown in the prompt), the description doesn't need to explain return values. The parameter documentation is excellent, and the basic purpose is clear. However, for a list operation with filtering capabilities, the description could benefit from mentioning sorting behavior, result format expectations, or error conditions to be fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the input schema, which has 0% description coverage. It clearly explains each parameter's purpose, format requirements (YYYY-MM-DD for dates), optional nature, default values, and for the 'state' parameter, provides the specific enum values (draft, reported, approved, done, refused). This comprehensive parameter documentation 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'List existing expenses' which is a specific verb+resource combination. It distinguishes itself from siblings like 'create_expense', 'delete_expense', and 'update_expense' by focusing on retrieval rather than mutation. However, it doesn't explicitly differentiate from other list tools like 'list_expense_reports' or 'list_expense_attachments'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. There's no mention of when to choose this over 'list_expense_reports', 'search_records', or other filtering tools. It also doesn't indicate prerequisites like authentication requirements or access permissions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions pagination behavior (limit/offset defaults) which is helpful, but doesn't cover important aspects like authentication requirements, rate limits, error conditions, or whether this is a read-only operation. For a listing tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and uses bullet-like formatting. Every sentence adds value, though the 'List products in Odoo.' opening could be slightly more informative about scope or context. Overall efficient with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters with 0% schema coverage, the description does an excellent job documenting parameter semantics. The presence of an output schema means the description doesn't need to explain return values. However, for a tool with no annotations, it could better address behavioral aspects like authentication, permissions, or error handling to be fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics despite 0% schema description coverage. It explains what each parameter does, provides enum values for product_type (consu=Consumable, service=Service, product=Storable), clarifies boolean behavior for 'available', and documents default values for limit and offset. 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List products in Odoo' which is a specific verb+resource combination. It distinguishes itself from sibling tools like 'get_product' (singular retrieval) by indicating it returns multiple products, though it doesn't explicitly contrast with other list_* tools like 'list_contacts' or 'list_employees' which follow similar patterns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. While it's clearly for listing products, there's no mention of when to use 'list_products' versus 'get_product' (singular retrieval) or 'search_records' (more flexible searching). The description provides filtering parameters but no contextual guidance about tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states it's a creation operation. It doesn't disclose behavioral traits like whether this requires admin permissions, if duplicates are prevented, what happens to existing schedules, or any rate limits. The return format is mentioned but lacks detail on error cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Perfectly structured with a clear purpose statement followed by Args and Returns sections. Every sentence adds value with no redundancy. The formatting with bullet points enhances readability without verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with no annotations and 3 parameters, the description covers basic purpose and parameters well. However, it lacks important context about permissions, error handling, and system behavior. The output schema exists, so return values don't need explanation, but other behavioral aspects are underspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 semantic meaning for all three parameters: name examples, date format, and calendar_id default value with explanation. This adds significant value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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 public holiday'), the target system ('in Odoo'), and the resource type ('global time off on working calendar'). It distinguishes from sibling tools like 'list_public_holidays' by specifying creation rather than listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 doesn't mention prerequisites, permissions required, or contextual triggers for creating public holidays versus other time-off tools like 'create_leave_allocation'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions pagination parameters and return format, which is helpful, but doesn't cover important aspects like rate limits, authentication requirements, error conditions, or whether this is a read-only operation (though 'List' implies it). For a tool with zero annotation coverage, this leaves significant gaps in behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured and concise. It uses three clear sections (purpose, args, returns) with no wasted words. Each sentence earns its place by providing essential information. The formatting with clear headings makes it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there's an output schema (implied by 'Has output schema: true'), the description doesn't need to detail return values, and it appropriately describes the pagination parameters. However, for a tool with no annotations, it could provide more behavioral context about limitations or constraints. The presence of an output schema reduces the completeness burden, but some behavioral gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics despite 0% schema description coverage. It clearly explains both parameters: 'limit' as 'Maximum number of categories to return' with default 100, and 'offset' as 'Offset for pagination' with default 0. This fully compensates for the lack of schema descriptions and adds meaningful context beyond what the bare schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('available expense categories') with the clarifying detail 'service type products'. It distinguishes this tool from siblings like 'list_expenses' or 'list_products' by focusing specifically on expense categories. However, it doesn't explicitly contrast with all possible siblings, so it falls just short of 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.
Usage Guidelines2/5
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. There are several sibling list tools (e.g., list_expenses, list_products, list_expense_reports) but no indication of when this specific category listing is appropriate. The agent must infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 mentions pagination behavior (limit/offset) and filtering by state, which is useful. However, it doesn't cover important aspects like authentication requirements, rate limits, error conditions, or whether this is a read-only operation (though 'List' implies read-only).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement followed by well-organized parameter explanations. Every sentence serves a specific purpose with zero waste, and the information is front-loaded appropriately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 has output schema), the description covers the essential functionality well. The output schema existence means the description doesn't need to detail return values. However, for a list operation with filtering and pagination, some additional context about default ordering or result structure would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description provides essential semantic information for all 3 parameters: 'state' filtering options (draft, submit, approve, post, done, cancel), 'limit' as maximum number of reports, and 'offset' for pagination. This compensates well for the schema's lack of descriptions, though it doesn't specify format constraints for the state parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and resource 'expense reports (expense sheets)', making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'list_expenses' or 'list_expense_attachments', which would require more specific scope information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives like 'list_expenses' or 'search_records'. The description only explains what the tool does, not when it's the appropriate choice among available options.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It implies a read-only operation by using 'List' and mentions pagination behavior via 'limit' and 'offset', which adds some context. However, it doesn't disclose other behavioral traits like authentication needs, rate limits, or error handling, leaving gaps for a tool with no 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.
Conciseness5/5
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 sections for Args and Returns. Every sentence adds value without redundancy, 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.
Completeness4/5
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 simple parameters) and the presence of an output schema (implied by 'Returns' in the description), the description is reasonably complete. It covers purpose, parameters, and return values, though it could benefit from more behavioral context given the lack of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 'limit' controls the 'Maximum number of projects to return' and 'offset' is for 'pagination', providing context not in the schema. Since there are only 2 parameters and the description covers both adequately, it compensates well for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'List available projects in Odoo.' It specifies the verb ('List') and resource ('projects'), but doesn't explicitly differentiate from sibling tools like 'list_tasks' or 'search_records' that might also retrieve project-related data, though the resource specificity helps.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 sibling tools like 'search_records' (which might offer more flexible filtering) or context for project listing, leaving the agent to infer usage based on the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions that it returns a list of entries and includes pagination parameters (limit/offset), but fails to describe critical behaviors such as authentication requirements, rate limits, error conditions, or whether the operation is read-only (implied by 'List' but not explicit). For a tool with 6 parameters and no annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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 a parameter breakdown in a clear 'Args/Returns' format. Every sentence earns its place by providing essential information without redundancy, 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.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (6 parameters, no annotations, but with an output schema), the description is largely complete. It covers all parameters thoroughly and notes the return type, though it could benefit from more behavioral context (e.g., permissions or error handling). The presence of an output schema reduces the need to detail return values, but some gaps remain in usage guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the input schema, which has 0% description coverage. It clearly explains each parameter's purpose, format (e.g., 'YYYY-MM-DD' for dates), default values, and optionality. This fully compensates for the schema's lack of descriptions, making parameter usage clear to the agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('existing timesheet entries'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'get_timesheet_summary_by_employee' or 'list_tasks', which might also involve timesheet-related data, so it doesn't achieve full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'get_timesheet_summary_by_employee' or 'search_records'. It lacks any context about prerequisites, typical use cases, or exclusions, leaving the agent to infer usage from the parameter list alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers limited behavioral insight. It states the tool creates allocations and returns confirmation with IDs, but doesn't disclose critical traits like whether this is a mutating operation (implied by 'create'), permission requirements, error conditions, or rate limits. The description doesn't contradict annotations (none exist), but fails to provide sufficient context for safe and effective use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement followed by parameter details and return information. It's appropriately sized for an 8-parameter tool, though the parameter explanations could be more front-loaded (they come after 'Args:'). Every sentence adds value, with no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (8 parameters, mutation operation) and lack of annotations, the description does a good job explaining parameters and the return value. The output schema exists, so the description doesn't need to detail return values. However, it could better address behavioral aspects like error handling or dependencies on other tools (e.g., list_leave_types).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds substantial meaning beyond the input schema, which has 0% description coverage. It explains each parameter's purpose (e.g., 'leave_type_id: Leave type ID (see list_leave_types)', 'all_employees: If True, allocate to all employees'), including optionality, defaults, and references to other tools. This fully compensates for the schema's lack of descriptions, making parameters clear and actionable.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates leave allocations for employees, which is a specific verb+resource combination. It distinguishes itself from sibling tools like 'approve_leave_allocation' and 'list_leave_allocations' by focusing on creation rather than approval or listing. However, it doesn't explicitly differentiate from other creation tools like 'create_contact' or 'create_expense' beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through parameter documentation (e.g., 'employee_id: Specific employee ID (optional)'), suggesting when to use certain parameters, but lacks explicit guidance on when to choose this tool over alternatives. It doesn't mention prerequisites like needing valid leave types from 'list_leave_types' or clarify mutual exclusivity between employee_id, department_id, and all_employees.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 mentions pagination behavior (limit/offset defaults) and filtering capabilities, which is helpful. However, it doesn't disclose important behavioral traits like whether this is a read-only operation (implied but not stated), authentication requirements, rate limits, error conditions, or what happens when no filters are applied (returns all invoices?). The description adds some context but leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, args, returns) and uses bullet-like formatting. Every sentence earns its place by providing essential information. It could be slightly more concise by combining some explanations, but the structure makes it highly scannable and the information density is good.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (7 parameters, no annotations, but has output schema), the description is reasonably complete. It thoroughly documents all parameters and their semantics. The output schema exists, so the description doesn't need to explain return values. The main gaps are behavioral context (auth, errors, etc.) and usage guidelines, but for a listing tool with good parameter documentation, this is fairly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics that fully compensate for the 0% schema description coverage. For each of the 7 parameters, it explains: 1) invoice_type values and their meanings (out_invoice=customer, etc.), 2) state values (draft, posted, cancel), 3) partner_id purpose (filter by partner), 4) date_from/date_to format (YYYY-MM-DD), and 5) limit/offset defaults and purposes. This adds substantial meaning beyond what the bare schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'List invoices in Odoo.' This is a specific verb+resource combination that distinguishes it from sibling tools like 'get_invoice' (which presumably retrieves a single invoice). However, it doesn't explicitly differentiate from other list tools (e.g., 'list_contacts', 'list_products'), though the resource specificity makes the purpose clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 when to use 'list_invoices' versus 'get_invoice' (for single invoice retrieval) or 'search_records' (which might offer more flexible searching). There are no explicit when/when-not instructions or alternative tool recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the critical behavioral constraint ('only if in draft state') which is valuable context beyond basic deletion. However, it doesn't mention authentication requirements, error conditions, or what happens if the expense isn't in draft state.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured with three brief, purposeful sentences: the core functionality, the parameter explanation, and the return value. Every sentence earns its place with zero wasted words, and the most important information ('only if in draft state') is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter destructive operation with no annotations but with an output schema, the description provides good coverage: purpose, constraint, parameter meaning, and return indication. The main gap is lack of error handling details, but the presence of an output schema reduces the need to fully describe return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides a clear explanation of the single parameter ('ID of expense to delete'), which adds meaningful context beyond the schema's basic type information. With 0% schema description coverage and only one parameter, this adequately compensates for the schema's lack of semantic information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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 ('an expense'), with the specific constraint 'only if in draft state' that distinguishes it from other deletion operations. This provides precise differentiation from sibling tools like 'delete_timesheet' or general deletion operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'only if in draft state', providing clear context for when to use this tool. However, it doesn't mention alternatives (like what to do if the expense isn't in draft state) or compare with other expense-related tools like 'update_expense' or 'list_expenses'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 clearly indicates this is a mutation operation ('Update') and specifies the draft-state constraint, which is valuable behavioral context. However, it doesn't mention permission requirements, whether the update is reversible, rate limits, or what happens to unchanged fields. The description adds some behavioral value but leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement followed by organized parameter documentation. Every sentence earns its place by providing essential information. It could be slightly more concise by combining some parameter explanations, but the structure is logical and front-loaded with the most important constraint.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an 8-parameter mutation tool with no annotations, the description does well by explaining all parameters and the draft-state constraint. The presence of an output schema means the description doesn't need to detail return values. However, for a mutation tool, it could better address behavioral aspects like error conditions or permission requirements to be fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by providing detailed parameter documentation. Each parameter is clearly explained with examples (e.g., date format 'YYYY-MM-DD', currency codes 'EUR/USD', payment mode options), optional status indications, and semantic meaning beyond what the bare schema provides. This adds substantial value beyond the minimal schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Update an existing expense') and resource ('expense'), with the important constraint 'only if in draft state' that distinguishes it from sibling tools like 'delete_expense' or 'submit_expense_report'. This provides precise differentiation from other expense-related operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use this tool ('only if in draft state'), which implicitly suggests when not to use it (when expense is not in draft). However, it doesn't explicitly mention alternatives like 'create_expense' for new expenses or 'delete_expense' for removal, nor does it specify prerequisites like checking expense status first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mcp-odoo MCP server](https://glama.ai/mcp/servers/industream/mcp-odoo/badges/card.svg)](https://glama.ai/mcp/servers/industream/mcp-odoo)

Score Badge

Copy to your README.md:

[![mcp-odoo MCP server](https://glama.ai/mcp/servers/industream/mcp-odoo/badges/score.svg)](https://glama.ai/mcp/servers/industream/mcp-odoo)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/industream/mcp-odoo'

If you have feedback or need assistance with the MCP directory API, please join our Discord server