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 that the tool writes by default, that dry_run avoids writing, that date defaults to today, that hours must be positive, and that the response format differs in each mode. This provides meaningful information beyond the schema, though expected side effects like duplicates or permissions are not covered.

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

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

The description is two compact chunks: the first establishes the core behavior and return shape, the second gives constraints and dry_run behavior. It wastes no words and repeats nothing already in the schema.

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

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

For a simple creation tool with no output schema and no annotations, the description covers the main behavioral details a caller needs: default date, constraints, return values, and a non-write dry_run path. It could further explain the description parameter or explicitly state that task_id is required, but the schema already marks that requirement.

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

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

Schema description coverage is 0%, so parameter semantics rely solely on the description. It usefully explains constraints for hours (>0) and date (YYYY-MM-DD) and clarifies dry_run behavior. However, it does not elaborate on task_id or description, though their meaning is inferable from schema titles.

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

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

The description clearly identifies the action and resource: 'Log hours worked on a task' with a destination given by the tool name create_timesheet. It is evidently distinct from update_timesheet and list_timesheets among the siblings, but it does not explicitly call out that distinction.

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

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

There is no explicit when-to-use guidance or comparison with alternatives like update_timesheet or list_timesheets. The description conveys the basic intent but leaves the agent to infer when to select this tool over its siblings.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. 'Fetch' implies a read operation and the mention of full detail fields suggests the response contents. However, it does not explain behavior on missing IDs, permissions, scoping to a project/workspace, or the exact response shape beyond a few partial fields.

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

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

One sentence, front-loaded with the core action and identifier, and the example fields in parentheses are useful without flsg or repetition. Every word contributes meaning.

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

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

The tool is simple: one required parameter, no nested objects, no output schema, and the description tells the agent that it returns full task details like hours, progress, and stage. It is sufficient for invoking the tool correctly, though more exact output fields or error behavior would improve completeness further.

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

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

The schema has 0% description coverage and only 'task_id' with type integer. The description's 'by id' clarifies the parameter's role, but otherwise adds little semantic value beyond the parameter name, which is relatively self-explanatory for a simple id parameter.

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

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

The description uses a specific verb ('Fetch'), names a resource ('one task'), and specifies how to select it ('by id'). It also indicates the expected detail level ('full detail fields'), which distinguishes it from the sibling list_my_tasks.

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

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

The description makes it clear this tool is for retrieving a single task by ID, which implies it should be used when the agent already has a specific task_id and needs full task data rather than a list or mutation. It does not explicitly name alternatives or exclusion cases, but the context is evident.

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

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

With no annotations available, the description must carry the behavioral disclosure. It clearly indicates a read-only listing operation scoped to a specific server, but it does not explicitly state that no mutations occur, or describe authentication, error conditions, or ordering behavior. The term 'List' implicitly conveys read-only behavior, but more explicit disclosure would be stronger.

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

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

The description is a single focused sentence with no redundant words. It front-loads the action 'List' and immediately states the resource and expected output fields, making it efficient and easy to consume.

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

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

For a zero-parameter metadata query with an output schema available, this description is complete. It specifies the domain scope ('this server'), the object queried ('valid task workflow states'), and the exact fields returned, which is sufficient for an agent to know why and how to invoke the tool.

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

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

The tool has no parameters, so the description does not need to explain parameter behavior. The schema already fully covers this case, and the description adds useful context about what kind of values are returned.

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

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

The description clearly states a specific verb ('List'), a specific resource ('this server's valid task workflow states'), and the output fields ({code, label, terminal}). It is unambiguous and easily distinguished from the sibling tools, which operate on individual tasks, task lists, or timesheets.

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

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

The description implies the tool is used when an agent needs the set of valid workflow states for tasks, likely to feed other task operations. However, it does not explicitly state when to prefer it over a sibling tool or when not to use it.

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

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

With no annotations, the description carries the full burden and it delivers: it discloses default filtering behavior, the exact semantics of limit=0, the date format (YYYY-MM-DD) for the deadline window, and the fact that state filtering uses exact state codes. This gives the agent a solid behavioral model beyond the raw schema.

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

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

The description is two tight, front-loaded sentences. The first sentences establishes purpose and scope; the second packs in defaults, filters, and limit semantics without any redundant phrasing. Every sentence earns its place.

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

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

Given an output schema exists, return values are already covered. The description also covers all parameters, defaults, and edge cases like limit=0. Minor gaps remain: exact valid state codes are not enumerated, stage_id and project_id are not further elaborated, and no mention of sorting/pagination, but these are not critical for correct invocation.

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

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

Schema description coverage is 0%, so every parameter must be explained in the description. The description explicitly mentions all 7 parameters: include_done, project_id, stage_id, state, due_after, due_before, and limit. It adds meaningful details, such as limit=0 meaning 'no limit' and due_after/due_before expecting YYYY-MM-DD. This more than compensates for the empty schema descriptions.

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

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

The description opens with a specific verb and resource: 'List the caller's Odoo tasks (tasks they are assigned to)'. This clearly distinguishes it from sibling tools like get_task (single task) and update_task (mutation). The scope is precise and unambiguous.

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

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

The description gives clear contextual guidance: it explains the default exclusion of terminal states (done/cancelled/closed), how include_done=true overrides that, and lists the optional filters. It does not explicitly name alternative tools or say when not to use the tool, but the intended use case is communicated effectively.

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

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

'List' is a non-destructive verb and 'available on the server' gives some context. However, with no annotations, the description still doesn't disclose edge behaviors such as return scope, ordering criteria, or why the system has both stages and get_task_states.

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

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

everything sentence earns its place. It states the exact model/resource, including the parenthetical project.task.type, without any filler.

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

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

The tool is appropriately simple: no parameters and an output schema exists, so the description gives sufficient context for calling it. A slight explanation of its relationship to 'get_task_states' would make it truly complete.

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

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

There are zero parameters, so the description need not explain parameter meaning. Even with a 100% schema coverage and no parameters, the baseline is a 4, and the description properly offers no unnecessary parameter detail.

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

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

The description clearly identifies the action ('List') and resource ('task stages (project.task.type)') and adds server-wide scope. It is understandable, though it does not explicitly differentiate itself from the sibling 'get_task_states'.

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

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

Basically describes what it does, but no explicit guidance is given about when to prefer this over sibling tools. The term 'available on the server' implies a lookup, but this is not elaborated.

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

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

With no annotations present, the description carries the full burden of behavioral explication. It discloses that results are restricted to the caller's entries, that ordering is newest first, and that a limit can cap results with a 50-row default. This gives the agent a reliable mental model of the operation's scope, though it does not go into details like pagination or what fields are returned, but those are covered by the output schema.

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

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

Two compact sentences, with the most important information front-loaded (what it lists and the file.. orer). Each sentence adds value: the first establishes purpose and suffix, the second defines the optionality. There is zero filler.

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

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

All three parameters are elaborated in the description, the operation's scope and graceful default are clear, and context for read-only behavior is implicit. The existing output schema covers the return structure, so omitting it is not a gap. Completion covers all necessary details for an agent to decide and invoke this tool correctly.

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

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

The schema description coverage is 0%, so the explanation is essential. Ths description gives synificant semantics to all three parameters: task_id restricts to one task, days limits the time window, and limit caps row count and gives a clear default. This fully compensates for the missing schema documentation.

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

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

The description names the exact resource ('timesheet entries') and action ('List'), and adds a scoping detail ('the caller's') that distinguishes it from any general timesheet query. It is clearly differentiated from sibling tools like create_timesheet, update_timesheet, or list_my_tasks by referring specifically to timesheet entries and presenting the read-only nature of the operation.

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

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

The description indicates this is for retrieving the caller's own entries and provides optional filters to narrow results to a task or a number of days, which helps choose appropriate arguments. It does not explicitly mention when to use a sibling tool instead (e.g., create_timesheet for creating new entries), but the purpose is clear enough that no leading exclusions are needed.

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

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

With no annotations provided, the description carries the full burden. It discloses the notification side effect and explains the dry_run behavior, including that dry_run returns a dry_run response rather than a message ID. This goes beyond the minimal mutation description, though more detail on permission requirements or failure modes would be stronger.

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

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

The description is brief and effective, putting the core action and side effect in the first line, then providing the exact return shapes. Every sentence is useful and there is no filler.

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

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

The tool is simple with only three parameters, and the description covers its purpose, side effect, and return format despite there being no output schema or annotations. Some especially notable gaps include no documentation of possible errors or restrictions on message content, but the key usage details are present.

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

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

Schema coverage is 0%, so the description must compensate for all parameter meaning. It adds useful semantics only for dry_run, explaining what happens when the flag is true. The roles of task_id and message are left to their titles and obvious context, but no format, constraints, or additional behavior are described, which is not enough compensation.

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

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

Description states a specific verb ('Post'), a specific resource (a message to a task's chatter), and the key side effect ('followers get notified'). This is unambiguous and distinguishes it from all sibling tools, none of which post messages.

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

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

The description implies when to use the tool by its action, but provides no explicit or even implicit guidance on when not to use it or when to prefer an alternative. None of the siblings perform a similar action, so no exclusion is strictly needed, but the guidance relies entirely on inference.

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

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

With no annotations provided, the description carries the full behavioral burden. It explains that updates execute immediately unless dry_run=true, that dry_run writes nothing and returns a values object, and that progress is computed rather than directly settable. It does not cover error conditions or permissions, but the main side-effect profile is disclosed.

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

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

The main execution semantics are front-loaded, and every field entry in the compact list adds meaning. The list is semicolon-heavy but this is an acceptable way to pack needed detail. No filler or repeated wording is present.

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

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

Given the absence of annotations and output schema, the description is close to complete for invocation: all fields are described, controlled values are sourced, and dry-run feedback is specified. The normal non-dry-run return value is not described, but an agent still has enough to select and invoke the tool with correct arguments.

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

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

Schema description coverage is 0%, so the description must define each parameter and it largely does: append_description appends after a blank line while description replaces, allocated_hours is planned effort, progress is computed, priority has a range, deadline has a format, state is a workflow code, and stage is an exact display name. This substantially exceeds what the schema provides.

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

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

The description opens with a clear verb and resource: update a task's mutable fields. It specifically says only mutable fields are affected and that execution is immediate unless dry_run is used, which distinguishes this from reading tools like get_task and list_my_tasks.

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

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

The description gives practical usage guidance: prefer allocated_hours over progress, use workflow codes from get_task_states, and use exact stage display names. It also clearly marks dry_run mode as a simulation. It does not explicitly compare with sibling alternatives, but the resource and verb are distinctive enough to avoid confusion.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses the success return format, explains dry_run behavior explicitly as returning vals without writing, and reveals that changing task_id moves the entry while keeping its project consistent. This goes beyond the schema, though it does not address failure scenarios or validation errors.

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

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

Two pragmatic sentences: the first states the operation and success response, the second packs the key constraints into a dense but readable block. No filler or repeated schema information.

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

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

Given six parameters, no annotations, and no output schema, the description covers the main invocation paths and both response modes. It could be more complete by noting expected error behavior for invalid/missing update fields or ownership/access expectations, but it supplies enough for an agent to call the tool correctly in normal cases.

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

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

With 0% schema description coverage, the description must add parameter meaning, and it does: it notes hours must be > 0, date must be YYYY-MM-DD, at least one of the four update fields is required, and dry_run skips writing. It also explains task_id's move semantics, which the schema's bare property completely omits. Only entry_id is left ambiguous, but its purpose is clear from the tool name and required status.

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

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

The description opens with 'Modify an existing timesheet entry', a specific verb and resource that clearly distinguishes the tool from siblings like create_timesheet and list_timesheets. It also states the success return payload, removing ambiguity about the operation's outcome.

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

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

The description communicates clear usage context by specifying that at least one update field must be provided, and the term 'existing entry' implies this is not for creation. However, it does not explicitly contrast with alternatives such as create_timesheet for new entries or update_task when task-level fields should be changed, so usage guidance is mostly implied.

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