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

Annotations already indicate a non-read-only, non-idempotent, non-destructive operation. The description adds context about creation scope and nesting but no additional behavioral detail like return value, permission needs, or side effects. It is consistent and adequate given the annotation coverage.

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

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

Two sentences, no unnecessary words. The primary action and scope are front-loaded, and the usage hints follow compactly.

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 creation tool with 9 parameters and no output schema, the description covers the key workflow and the two most nuanced parameters. It is solidly complete, though it does not describe the return value or confirmation behavior of the created work package.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning for type_id (source it from list_project_types) and parent_id (nesting behavior), going beyond the schema's field-level descriptions.

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

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

Description states a specific verb ('Create'), a clear resource ('new work package'), and the project context. It names the kind of objects handled (Epic, User Story, Task, Bug), and by saying 'a new' it implicitly distinguishes from the bulk sibling create_work_packages_bulk.

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?

Gives clear action-oriented guidance: use list_project_types first for type_id, and pass parent_id to nest a User Story under an Epic. It establishes context and prerequisites, though it does not explicitly mention when not to use this tool or point to the bulk alternative.

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

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

Annotations provide only generic flags (readOnly=false, idempotent=false, etc.), so the description carries important behavioral weight. It discloses a per-item success/failure report, which is valuable for a bulk operation where partial failures are likely. It stops short of describing the report's exact shape or what happens on mixed success/failure, but the disclosure is solid.

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

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

Three sentences, all useful: what the tool does, a concrete bulk-use example, a key parameter nuance, and the return behavior. No filler or repetition of schema details.

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

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

For a bulk creation tool with full schema coverage and no output schema, the description states the core behavior, the flexibility of parent_id, and the per-item report. It could be slightly richer about the shape of the per-item report or any ordering implications, but nothing essential is missing for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context by explaining that each item can have its own parent_id, allowing stories to attach to different Epics in the same call. This goes beyond the schema's generic field description and guides parameter usage.

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

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

The description states a specific verb and resource ('Create multiple work packages in one call') and clarifies the bulk nature, distinguishing it from the singular create_work_package sibling. The example ('User Stories parsed from a Word document') further grounds what this tool is for.

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

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

It provides a concrete use case ('all the User Stories parsed from a Word document') and explains how items can attach to different Epics, making the bulk scenario clear. It does not explicitly mention the singular create_work_package alternative, but the 'one call' phrasing and sibling list make the intended usage obvious.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the safety profile is clear. The description adds minimal behavioral context by promising 'detailed information', but it does not disclose response shape or error behavior.

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

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

The description is a single concise sentence with no filler and no duplication of schema content. It is front-loaded with the action and resource.

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

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

For a simple one-parameter read tool, the description plus annotations and schema are sufficient to invoke it correctly. The only real gap is that 'detailed information' is vague about the exact fields returned, but this does not hinder 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?

The schema covers 100% of parameters and the project_id description already explains accepted formats (numeric ID or slug). The tool description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description states a clear verb-resource pair: get detailed information about a specific project. The word 'specific' implicitly distinguishes it from list_projects, though no sibling is explicitly named.

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

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

Usage is implied: use this tool when you need details for a particular project using its ID or slug. There is no explicit when-to-use or when-not-to-use guidance, nor a reference to alternatives like list_projects.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds no extra behavioral context such as return format, error cases, or relation to other resources.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to conveying the tool's core operation.

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?

This is a simple, read-only getter with one required parameter and strong annotations. The description and schema together give enough context for an agent to invoke it correctly, though it does not describe the response shape or what fields 'details' includes.

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

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

Schema description coverage is 100%, so the single required parameter time_entry_id is already documented. The description adds no additional meaning beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description uses a clear verb and resource: 'Get details of a specific time entry'. It distinguishes itself from list_time_entries by emphasizing a single, specific entry, though it does not explicitly name or contrast with sibling tools.

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

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

The wording implies this tool is for retrieving one specific time entry, especially in contrast to list_time_entries, but it provides no explicit guidance on when to choose it over alternatives or any exclusions.

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

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

Annotations already fully declare the safety profile (readOnly, idempotent, non-destructive). The description adds no behavioral context beyond that, such as return format, permissions, or scoping. With rich annotations, this is adequate but not additive.

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

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

A single clear sentence that is front-loaded and contains no filler. It states the action and resource efficiently, appropriate for a simple getter.

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 single-parameter read-only operation with strong annotations, the description is sufficient to orient an agent. It could have clarified what 'detailed' includes or whether any user can be fetched, but the simplicity of the tool makes that a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents the only parameter (user_id). The description adds no extra semantic meaning about the parameter, maintaining the baseline score.

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 'Get detailed user information' clearly identifies the verb and resource: it retrieves data about a single user. It is distinguishable from sibling list_users by the singular 'user' and 'detailed', though it does not explicitly state that it fetches by user_id.

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

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

Usage is implied by the name and schema: use when you need details of a specific user by ID. However, no explicit guidance is given about when to choose this tool over list_users or other siblings, so the agent must infer the context.

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

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

Annotations already declare the operation as read-only, idempotent, non-destructive, and open-world. The description adds minor value by indicating the response includes description and links, but it does not discuss error behavior, pagination, or response shape beyond those hints.

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

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

The description is a single sentence that is front-loaded with the action and resource. Every word earns its place, and there is no redundant or filler content.

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 read-only get-by-id tool with strong annotations, the description is mostly complete. Since there is no output schema, mentioning 'description and links' gives some return-value context, though it does not enumerate the full set of returned fields.

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

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

The input schema has 100% description coverage for the single parameter, work_package_id, which is adequately described as 'Work package ID'. The tool description does not add additional semantic detail about the parameter beyond what the schema already provides.

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

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

The description states a specific verb and resource: 'Get detailed information about a work package including description and links'. This distinguishes it from list/search variants by indicating detail-level retrieval of a single package, though it does not explicitly name sibling tools.

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

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

Usage is implied: use this tool when you need detailed information about one specific work package. However, there is no explicit guidance about when to prefer list_work_packages, search_work_packages, or get_work_package_activities instead.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds that the result is a history of updates, which is useful return-shape context, but it does not disclose details like pagination behavior, ordering, or filtering beyond the offset parameter already in the schema.

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

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

A single, front-loaded sentence states the core purpose without filler or repetition. Every word earns its place.

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

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

For a simple read-only tool with two well-described parameters and no output schema, the description conveys the essential return concept. It is nearly complete, though it could add a bit more specificity about the shape or ordering of the returned activity entries.

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

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

Schema description coverage is 100%, and the schema already explains work_package_id and offset. The description adds no additional parameter-level meaning, so it remains at the baseline for fully documented parameters.

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

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

The description uses the specific verb 'Get' with a clear resource, 'activity history and updates' for a work package. This distinguishes it from sibling tools like get_work_package and list_work_packages, which return current details or lists rather than activity history.

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 supplies clear context: use this tool when you need a work package's activity history or updates. It does not explicitly name alternatives or exclusion conditions, but the purpose is specific enough to guide selection among the sibling tools.

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

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

Annotations already communicate the read-only, idempotent, non-destructive nature of the tool. The description adds the 'all projects with optional filtering' scope, which is useful, but it does not add further behavioral detail such as default pagination or result shape. No contradiction with annotations.

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

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

A single sentence that states the action, resource, and filtering capability with no wasted words. The key scope ('List all projects') is front-loaded.

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

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

Given the low complexity, zero required parameters, full schema description coverage, and strong read-only annotations, the definition is effectively complete for invoking the tool. It could mention pagination defaults or return format, but the schema already documents the offset parameter.

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

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

Schema description coverage is 100%, so all three parameters already have explicit descriptions. The tool description merely restates name/status filtering without adding new semantic details, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('List') with a clear resource ('OpenProject projects') and names the optional filters ('by name and status'). It is readily distinguished from sibling tools like get_project, list_work_packages, or list_project_types.

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?

Use is implied by the imperative description: call this tool when you want a list of projects rather than a single project or work packages. However, no alternatives are explicitly named and no when-not-to-use guidance is provided.

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

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

Annotations already establish that the operation is read-only, idempotent, and non-destructive. The description adds useful behavioral context beyond that: it scopes results to the project and reveals that each type is returned with its ID and examples like Epic and Task, which is exactly the information an agent needs before creating work packages.

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

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

A single, compact sentence that front-loads the core action and result, then adds the use-case context with no filler. Every part of the 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?

For a simple, read-only list operation with one required parameter and rich annotations, the description covers what the tool does, what it returns, and why an agent would call it. No output schema is present, but the description supplies the key details needed for correct invocation.

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

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

Schema coverage is 100% and the single parameter project_id already has a clear description. The description's "in a project" phrasing lightly reinforces the parameter's role but adds no new format, syntax, or default information, so the baseline of 3 applies.

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

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

The description uses a specific verb ("List") and resource ("work package types available in a project"), gives examples of the returned values, and states that IDs are included. This makes it easy to distinguish from sibling tools like list_work_packages or list_projects, which operate on different entities.

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

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

The phrase "needed before creating a work package of a specific type" gives clear when-to-use context and ties it to create_work_package. It does not explicitly enumerate alternatives or exclusion conditions, so it stops short of a 5, but the context is unambiguous.

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

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

Annotations already establish read-onl, idempotent, and non-destructive behavior, so the description carries a lighter burden. It adds filtering scope but does not disclose behavior such as default result limits, pagination behavior, or what happens with no filters. No contradiction with annotations.

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

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

A single, front-loaded sentence that states verb, object, and scope with zero waste. Every word earns its place.

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

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

Adequate for a simple filtered-list tool with rich annotations and full schema coverage, but the lack of an output schema and any mention of default behavior or pagination leaves minor gaps. Still, an agent can select and invoke it correctly for common 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?

Schema description coverage is 100%, so the baseline is 3. The description's filter categories roughly mirror the parameter list but add no new semantic detail beyond 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?

States a specific action (List) and resource (time entries), and lists the supported filter dimensions. It does not explicitly distinguish itself from get_time_entry, but the plural 'List' and filter scope make the purpose 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 implies this is the tool for querying lists of time entries with optional filters, but it provides no explicit when-to-use/when-not guidance or mention of alternatives. An agent must infer that get_time_entry is for single-record retrieval.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the 'all users' scope, which is useful context, but does not disclose whether the response is paginated, what default page size is, or whether results are limited in any way. With strong annotations, a 3 is appropriate.

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

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

One concise sentence that states the action and scope with no filler. It front-loads the essential purpose and does not repeat annotation information.

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

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

For a simple, read-only list tool with full schema coverage and a safe annotation profile, the description is adequate. However, there is no mention of pagination behavior, default limits, or response format, and no output schema exists, so an agent may not know how many results to expect or how to iterate pages. Slight gap given the lack of output schema.

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

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

Schema description coverage is 100%, so the single parameter (offset) is already documented in the schema. The description does not add extra meaning about offset format, bounds, or interaction with pagination, but given the schema fully covers it, baseline 3 is correct.

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

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

The description states a clear verb and resource: 'List all users in the OpenProject instance'. It is specific about scope (all users, instance-wide) and distinct enough from the sibling get_user (which fetches a single user) and list_projects (different resource). It lacks some detail on pagination, but the core purpose is unambiguous.

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

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

The description implies use when you need all users, and the sibling list includes get_user for retrieving a specific user, so an agent could infer when to choose this tool. However, it provides no explicit guidance on when to prefer list_users over get_user or other list tools, nor does it mention pagination behavior with offset.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is well covered. The description adds only the notion that work packages include tasks, bugs, features, etc., which is mild domain context. It does not describe pagination behavior beyond the schema or return characteristics, but the annotation coverage lowers the bar.

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: 'List workpackages with advanced filtering (tasks, bugs, features, etc.).' It is front-loaded with the action and resource, and every word earns its place. There is no filler or redundancy.

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

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

For a list tool with 6 optional parameters, all fully documented in the schema, and no output schema or nested objects, the description plus schema are largely sufficient. The main gap is the lack of explicit guidance on when to use this tool vs. search_work_packages, but that does not make the definition incomplete for basic 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 100%, and every parameter has a clear description (e.g., offset, search, status, priority, project_id, assignee_id). The tool description adds no new semantics beyond saying 'advanced filtering,' so it does not compensate with extra meaning. A baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'List work packages with advanced filtering.' It identifies a specific verb and resource, and the mention of filtering distinguishes it from simple retrieval tools like get_work_package. However, it does not explicitly differentiate itself from the sibling search_work_packages.

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

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

The description implies usage for listing and filtering work packages, and the parenthetical 'tasks, bugs, features, etc.' gives some context about the domain. It does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives like search_work_packages. The usage is clear enough by implication 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.

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no behavioral detail beyond basic search semantics, such as open-world result completeness or pagination behavior, but it is consistent with the annotations.

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

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

A single, front-loaded sentence conveys the tool's core behavior with no redundant words. It is appropriately sized for a simple search tool whose parameter details live 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?

With full parameter descriptions, a read-only/idempotent annotation set, and a simple search purpose, the definition provides enough context for correct invocation. It could be stronger by mentioning pagination or pointing to list_work_packages for unfiltered browsing, but those are not blocking gaps.

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

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

All five parameters are fully described in the input schema (100% coverage), so the schema carries the documentation burden. The description only adds a generic 'optional filters' phrase and no per-parameter meaning beyond what the schema already provides.

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

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

The description states a specific action ('Search'), a resource ('work packages'), and the mechanism ('by text query with optional filters'). This clearly separates it from siblings like list_work_packages, which lists without a query, and get_work_package, which fetches a single item.

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 wording implies use when a text query is available and when filtering is desired, but it does not explicitly say when to prefer search_work_packages over list_work_packages or get_work_package. No exclusions or alternative recommendations are provided.

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