OpenProject MCP

by jtauschl

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v0.3.8
Disambiguation3/5
Tools generally target distinct resources (projects, work packages, sprints, wiki pages, etc.), but some overlap exists: list_ relations vs get_work_package_relations, and get_project vs get_project_admin_context vs get_project_configuration may cause selection confusion. However, most tools are clearly named by their resource and action.
Naming Consistency4/5
The server consistently uses the verb_noun pattern with list_ for collections and get_ for single items. Minor inconsistencies like get_work_package_relations (plural but returns a list) and mixed use of list_ for some single-resource collections exist, but overall the convention is predictable.
Tool Count2/5
58 tools is exceptionally high for an MCP server, exceeding the typical 3–15 range by a wide margin. This is likely to overwhelm agents and create decision fatigue, even if each tool covers a distinct resource.
Completeness2/5
The server is purely read-only—there are no create, update, or delete tools for any resource. While it covers many entities (projects, work packages, wiki pages, news, documents, sprints, boards), the lack of any mutation operations represents a significant gap for typical project management workflows.
Average 3.9/5 across 58 of 58 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- 3 of 4 community issues answered or closed in the last 6 months
- 396 commits in the last 12 weeks
- Last stable release on August 25, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
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?
There are no annotations, so the description carries the full burden of disclosing behavior. It only states that the operation 'returns' data, implying a read, but it does not mention authentication needs, error behavior, what happens when the project doesn't exist, or how the configuration is structured.
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 a single, front-loaded sentence with no wordy filler. It is concise and direct, though it is too terse to provide adequate context for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While the tool is simple (one parameter), the description omits important orientation cues: what 'project-scoped configuration' means, what configuration categories are included besides 'internal comment support', and how this relates to similar sibling tools. The presence of an output schema does not compensate for the description's lack of context on the input side.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema declares a single required 'project' string parameter, but schema description coverage is 0% and the description does not explain what format is expected (e.g., ID, key, href) or how to obtain valid project values. The parameter name itself is only minimally self-explanatory.
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 uses a specific verb ('Return') and resource ('project-scoped configuration'), with a concrete example ('internal comment support') that hints at its scope. It is distinct from sibling tools like get_instance_configuration (global vs project-scoped), though it does not enumerate what other configuration fields are included.
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_project, get_project_admin_context, or get_project_work_package_context. There are no exclusions, prerequisites, or hints about the intended use case.
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 provided, so the description bears the full burden. It says 'List... including principal and role names', implying a read operation, but does not disclose whether it includes nested memberships, pagination, or permission requirements. It does not contradict annotations (none provided), but it is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise sentence, front-loaded with the verb 'List'. It is efficiently written with no filler. However, it is under-specified, so while concise, it misses key details; still, conciseness itself is good.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with one parameter and no output schema, the description should at least clarify the parameter semantics and possibly common use cases. With 0% schema coverage and no annotations, the description is inadequate to fully understand the tool's behavior, especially given the need to differentiate from sibling tools. It is not complete enough to be reliably invoked.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, meaning the description does not explain the 'project' parameter beyond its name and type in the schema. The description says 'for a project' implicitly, but does not specify format, examples, or how to identify the project (ID? slug?). Since the tool has only one parameter, the description could easily add context; it fails to do so.
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 'List memberships for a project, including principal and role names' clearly states the action (list), the resource (memberships), and the scope (for a project). It also indicates the return includes principal and role names, which adds specificity. It distinguishes from siblings like get_membership (single) and list_projects (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?
No guidance on when to use this tool vs. alternatives. Siblings include get_membership, list_roles, list_projects, but the description does not explain when to choose this list over get_membership or any filtering/ordering options. It gives no context on use cases or limitations.
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 bears the burden of behavioral disclosure, yet goes only slightly beyond the tool name — stating it returns 'project metadata' and can 'optionally' return the 'writable work-package schema.' It fails to clarify what the 'writable' semantics are (e.g., side effects, auth requirements, when the type parameter is required). Not a contradiction, but minimally transparent.
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?
Single, front-loaded sentence with no filler words; reads efficiently and communicates the primary resource in the first few words. Loses one point because the information density could be higher given how little of the tool's purpose is covered.
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?
The tool has low complexity (2 params, no enums, nested objects absent) and an output schema, which lightens the descriptive load. However, the word 'optionally' is ambiguous — the description doesn't clarify when the schema should or shouldn't be requested — and the agent is left without enough to confidently reuse this tool in different scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description should compensate by documenting the parameters. The phrase 'for a given type' loosely mirrors the `type` parameter, but neither parameter ('project' nor 'type') is meaningfully explained — the agent can't tell what format/value the 'type' parameter accepts or when it should be omitted.
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?
Uses a clear verb+resource structure ('Return project metadata and, optionally, the writable work-package schema'), accurately describing what the tool does. However, it doesn't distinguish itself from similarly-named siblings like get_project_admin_context or get_project_configuration, so the agent can't readily see what makes this 'context' tool different.
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 when-to-use or alternative tooling is mentioned. Given the close sibling names (get_project_configuration, get_project_admin_context, get_project, get_type, list_work_packages), the description misses a critical opportunity to explain when this tool is preferred over its neighbors.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits, but it only states the verb 'List' without detailing side effects, permissions, or response characteristics, leaving behavioral expectations vague.
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 a single, concise sentence that places the verb upfront, making it efficient and well-structured.
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?
The description is adequate for a simple list operation with one parameter, but it lacks any mention of output format, error behavior, or additional context that might be needed without annotations or an output schema, leaving some gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description minimally explains that the 'project' parameter identifies the project for which categories are listed, but it does not clarify whether it expects an ID, name, or other identifier, offering limited added meaning beyond the 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 action (List) and the specific resource (work-package categories) within the context of a project, distinguishing it from sibling list tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No information is provided about when to use this tool versus alternatives, nor are any conditions or prerequisites mentioned.
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?
Without annotations, the verb 'Return' reasonably signals a read-only operation, and the examples clarify the kind of data returned. However, the description does not disclose permission requirements, error behavior, or whether the result is scoped by the current user—gaps that matter for an admin-related 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 a single front-loaded sentence with concrete examples and no filler. It avoids repeating schema details and communicates the tool's core purpose efficiently.
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?
The tool is simple and an output schema exists, so the description does not need to enumerate return fields. Still, it omits usage context and parameter-value guidance, and the presence of similar sibling tools means the description is only minimally complete for correct selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does not explain the project parameter beyond what the schema title already conveys. An agent is left to guess whether 'project' expects an ID, identifier, or some other form, so the description fails to compensate for the missing schema documentation.
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 states a concrete action ('Return') and a specific resource ('project admin metadata') with useful examples: lifecycle statuses, parent options, and writable fields. It is clear about what the tool provides, though it does not explicitly distinguish itself from similarly named siblings like get_project_configuration or get_project_work_package_context.
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 gives no guidance on when to use this tool versus alternatives. An agent must infer when 'admin metadata' is the right category, and the large sibling list contains several tools with overlapping names and purposes, making that inference risky.
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. However, it only says 'Get' without disclosing read-only nature, error handling, or expected behavior on missing sprint. It adds minimal behavioral context beyond the obvious.
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?
Description is a single concise sentence, front-loaded with the core action. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (one parameter, single retrieval), the description is incomplete because it lacks usage guidance and behavioral transparency. However, the output schema exists, so return values are not needed. But the description does not mention alternatives or side effects, making it incomplete for a robust agent decision.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% – description does not explain the sprint_id parameter beyond the schema. The phrase 'by id' implies the parameter is the identifier, but it does not clarify its source or format. Description fails to compensate for missing schema docs.
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?
Description states 'Get a Backlogs sprint by id' – clear verb (Get), specific resource (Backlogs sprint), and retrieval method (by id). Distinguishes from sibling list_sprints functions by indicating single-item retrieval.
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 on when to use vs. alternatives like list_sprints. The description does not mention alternatives or preconditions. It solely states the action without 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?
With no annotations, the description carries the full burden of behavioral transparency. It indicates a read-like 'Get' operation and an id parameter, but does not disclose behavior such as whether a non-existent id returns an error or empty result, any access requirements, or other side-effect-free guarantees. This is minimal information.
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 a single, concise sentence that immediately communicates the core operation. There is no wasted wording, and the key qualifier 'single' is front-loaded to clarify the scope.
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?
This is a simple fetch-by-id tool with a minimal schema and an output schema. The description provides the core function but lacks contextual completeness: it does not clarify the relationship to list_types or indicate the retrieval behavior when not found. It is minimally viable but could be improved with one sentence about alternatives or failure semantics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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. The description says 'by id' but never explicitly maps the id to the type_id parameter. It gives no additional context about the parameter beyond what the schema's property name already implies. For a single-parameter tool, this is a notable gap.
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 action ('Get') and resource ('a single work package type'), and explicitly notes retrieval is by id. This distinguishes it from list_types (which would return multiple types) and other get_* siblings for different resources.
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 given about when to use this tool versus alternatives. There is no mention that list_types is the appropriate tool for retrieving all types, nor any exclusions or prerequisites. The description simply states what it does, not why or when to use it.
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 does not state what happens for a non-existent/orphaned board id, whether authentication or workspace context is required, or the return shape beyond the output schema. The description adds only the 'saved' qualifier, which is thin 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 a single clear sentence with no filler, front-loading the action and target. Every word contributes meaning.
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 simplicity (one self-descriptive parameter) and the presence of an output schema, the description sufficiently orients an agent. It lacks some behavioral nuance (e.g., 404 behavior), but for a basic read operation, it is reasonably complete within the provided context.
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?
Schema description coverage is 0%, but there is only one parameter (board_id) whose purpose is self-explanatory from its name and type. The description's 'by id' reinforces the parameter role but adds no format, constraint, or lookup semantics beyond what the schema already conveys. A baseline 3 is appropriate.
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 uses a specific verb ('Get') with a clear resource ('saved OpenProject board/query') and identifies the lookup key ('by id'). It effectively distinguishes from sibling list tools like list_boards and list_grids by indicating retrieval of a single saved entity rather than enumeration.
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 context ('saved... by id' suggests retrieving a pre-existing board), but provides no explicit when-to-use guidance, nor does it name alternative tools or exclusion criteria. For a simple getter, the implied usage is adequate but not elaborated.
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 only restates the read intent as 'Get' and scopes the lookup to a project's category list. It does not disclose behavior when the category is missing, whether the operation is purely read-only, what permissions are required, or how errors are surfaced.
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 a single short sentence with the core action and scope front-loaded. There is no filler, and every word contributes to identifying the operation. This is appropriately concise for a simple read 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?
The tool is simple and the output schema covers return shape, but the description still leaves gaps: no guidance for choosing this over list_categories, no mention of not-found or error behavior, and no format for the project parameter. An agent can likely invoke it successfully on the happy path, but the description is not fully complete given the absence of annotations and schema descriptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description was expected to compensate for the bare input schema. It gives only a weak hint that project is the containing project and says nothing about how project should be specified or how category_id should be obtained. The property names and types in the schema carry the bulk of the meaning.
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 uses a specific verb ('Get') with a specific resource ('a single category') and scope ('from a project's category list'). The word 'single' clearly distinguishes it from the sibling tool list_categories, and the category resource separates it from the many other get_* siblings in the tool list.
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 the usage case: retrieve one category by ID from a project. However, it never explicitly states when to prefer this tool over list_categories or any other sibling, and it does not mention prerequisites such as obtaining a category_id from list_categories first. No alternatives or exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations and a minimal description, the tool's behavior is not fully disclosed. The word 'get' suggests a read-only operation, but it does not explicitly confirm the absence of side effects, error behavior for invalid ids, or permission requirements. The description lacks transparency about what happens on failure or if the id does not exist.
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 a single, clear sentence with no unnecessary words or redundant information. It is concise and to the point, which is ideal for a simple get operation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool lacks an output schema and the description does not mention what the return value will be (e.g., full status object, specific fields). It also omits any error handling or edge-case behavior. For a get operation, this leaves the user guessing about the response format, making the description incomplete.
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 single parameter 'status_id' is self-explanatory from its name and type (integer), and the description reiterates that it identifies the status. However, the description does not add any extra context about the id's meaning, range, or format, so it adds little beyond the schema itself. Given the schema covers the parameter, a score of 3 is appropriate.
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 action (get), the resource (work package status), and the specific identifier (by id). It distinguishes itself from the list_statuses sibling by indicating it retrieves a single item, making 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving one specific status when an id is known, but it does not explicitly state when to prefer this over list_statuses or when not to use it. It provides no guidance on prerequisites or conditions, so while the intent is clear, usage context is only implied.
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, the description carries the burden, and 'Get' does indicate a read-only operation while 'compact summary' hints at the output shape. It does not mention error behavior, authentication, or pagination, but for a simple get-by-id tool this is a moderate gap.
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 a single, front-loaded sentence with no filler or redundancy. It is appropriately concise for a one-parameter read tool.
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 a single required integer parameter and an output schema, the description is nearly complete for selecting and invoking the tool. It omits a pointer to list_versions for multi-version needs, but the simplicity of the tool limits the impact.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description only says 'by id,' which merely restates the version_id parameter without adding source, format, or usage nuance. It does not compensate for the lack of parameter documentation in 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 uses a specific verb ('Get'), names the resource ('version'), and indicates lookup by ID, which distinguishes it from sibling list_versions. The phrase 'compact version summary' is slightly vague about what is returned, but the core purpose is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The ID-based lookup implies the tool should be used when a specific version_id is known, rather than for listing versions. However, there is no explicit guidance about when to prefer list_versions or any exclusions/alternatives.
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 must convey behavioral traits. The verb 'Get' implies a read-only operation, but no additional context is given about error handling, auth requirements, or whether it returns metadata or file content. The description is minimally adequate but lacks deeper transparency.
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 a single concise sentence with no redundant content. It front-loads the action and resource, making it immediately scannable and 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?
For a simple getter with one parameter, the description is functional but minimal. It does not reference sibling tools or error behavior, though an output schema exists and might cover return details. The text alone leaves some context gaps, but given the tool's simplicity, it is adequate.
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 schema has a single required parameter 'attachment_id' with no description. The description's phrase 'by id' confirms that this parameter is the identifier to look up, adding slight clarity. However, it does not explain the scope or format of the ID, though the parameter name itself is self-explanatory. Given 0% schema coverage, the description provides only baseline compensation.
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 tool retrieves a single attachment by its ID. The verb 'Get' specifies the action, 'attachment' is the resource, and 'single by id' differentiates it from list operations among siblings. This is unambiguous and specific.
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 instead of alternatives like list_work_package_attachments or list_work_package_file_links. It does not mention any context, exclusions, or alternative tools, leaving the agent to infer usage solely from the tool name and parameter.
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, and the description adds no behavioral context beyond the read action implied by 'Get'. It does not disclose authentication needs, behavior when the id is not found, or any other side effects or constraints.
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 a single, clear sentence with no redundant words or filler. It is appropriately sized for a simple by-id retrieval tool.
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 (one required integer parameter and an output schema is present), the description is nearly sufficient. However, it lacks any mention of what the output contains, authentication, or how to handle missing news entries, which prevents a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already defines news_id as an integer. The description's 'by id' only restates the schema's parameter name and does not add meaningful semantics such as format, range, or the significance of the id. With 0% schema description coverage, the description should compensate but does not.
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 uses a specific verb ('Get') and explicitly identifies the resource ('a single news entry') and its lookup criterion ('by id'). This clearly distinguishes it from list_news and other get_* sibling tools.
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 when to use the tool: when you want a single news entry by id. However, it does not explicitly state when not to use it or mention alternatives like list_news, so the guidance remains mostly implicit.
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 burden of disclosing behavioral traits. It only says 'Get', which implies a read-only operation, but does not describe return format, error behavior when the ID is not found, authentication requirements, or any side effects. This is minimal behavioral disclosure.
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 a single, front-loaded sentence with no redundant words. It is appropriately concise for a simple get-by-id tool and every word contributes to conveying the tool's purpose.
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?
The description is complete for a simple single-item retrieval tool: it states what is retrieved and how (by id). The presence of an output schema (per context signals) means return values need not be described. However, it would benefit from mentioning how to obtain a priority_id or what happens if the ID is invalid, so it is not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description adds only 'by id', which does not meaningfully clarify the parameter beyond the schema's name and title. It does not explain the integer format, how to discover the ID, or any constraints. The description provides almost no added value for parameter understanding.
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 uses a specific verb ('Get') with a clear resource ('work package priority') and scope ('single... by id'), which distinguishes it from sibling tools like list_priorities that return collections. It is unambiguous about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the user must have or know the priority_id, but it does not explicitly state when to use this tool over alternatives like list_priorities, nor does it mention how to obtain valid IDs. Usage context is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for disclosing behavior. 'List' clearly implies a non-destructive read operation, but it does not mention output format, ordering, or access requirements. This is acceptable for a likely simple list operation, but lacks contextual depth.
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 a single, concise sentence that fully states the tool's purpose. Every word earns its place, and there is no unnecessary elaboration. This is appropriate for a zero-parameter listing tool.
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 low complexity (zero parameters, no nested objects, no output schema), the description is adequately complete for a simple list action. It could mention what the returned activities look like, but for the apparent simplicity of the tool, the current description suffices.
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 has zero parameters, so the baseline is 4. The description does not need to explain any parameters, and it correctly refrains from adding misleading syntactic details. The term 'available' adds slight semantic value about the scope of the list.
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 'List available time entry activities' uses a specific verb ('List') and a clear resource ('time entry activities'), making its purpose immediately understandable. It distinguishes itself from sibling tools like list_time_entries and list_categories by naming a distinct resource, though it relies on the tool name for full 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 on when to use this tool versus alternatives. There are no mentions of prerequisites, typical scenarios, or exclusions. The description simply states what it does, leaving the agent to infer usage from the name and sibling 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?
There are no annotations to rely on, and the description does not disclose any behavioral aspects beyond the name, such as authentication requirements, potential errors, or side effects. It merely restates the function without adding 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, lean sentence that conveys the core purpose efficiently. No unnecessary words or redundancy, making it a model of conciseness.
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 simple, parameterless tool with an output schema, the description is essentially complete. However, it could marginally benefit from a hint about when to use this over related 'get' tools, but given the presence of an output schema, it falls just short of perfect.
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 zero parameters, so the baseline is 4. The description does not add parameter-level details, but none are needed. The schema and empty property set already fully cover this aspect.
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 uses a clear verb ('Return') and a specific resource ('currently authenticated user's profile'). It unambiguously differentiates from sibling tools like 'get_my_project_access' by explicitly scoping to the current user's profile.
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, no exclusions, and no context about scenarios where it is appropriate. The description only states what it does, leaving the agent without decision-making help.
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 must disclose behavior. It only says 'Get a single document,' which implies read-only but omits details about error handling, authentication needs, or whether the document must exist. This is minimal and insufficient for a tool with zero 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 a single concise sentence with no unnecessary words. It is front-loaded and efficiently communicates the tool's core function.
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 simple get tool with one parameter and an output schema, the description is largely complete. It specifies the action and required input, and the output schema handles return details. The only gap is not mentioning the relationship to list_documents, but that is a usage nuance rather than a completeness failure.
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?
Schema description coverage is 0%, so the description must compensate. The phrase 'by id' indicates the parameter is an identifier, matching the schema's 'document_id' field. However, it adds little beyond the schema's existing title, lacking context on how to obtain the ID or any formatting constraints.
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 action and resource: 'Get a single document by id.' It uses a specific verb (get) with a resource (document) and scoping (by id), distinguishing it from siblings like list_documents.
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 requires a document ID, but does not explicitly explain when to use this vs alternatives (e.g., list_documents to obtain IDs). No exclusions or alternative tools are mentioned, leaving the agent to infer from the sibling list.
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?
No annotations exist, so the description is the only safety signal; 'Get' implies a read-only operation and 'compact summary' hints at the response shape. It does not disclose permissions, error behavior, or handling of unknown ids, but for a simple getter this is minimally acceptable.
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?
One short sentence with no redundant words; 'Get a compact membership summary by id' is front-loaded and immediately usable.
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 one required parameter and the presence of an output schema, the description is nearly sufficient for a basic get-by-id call. It would be more complete with an explicit pointer to list_project_memberships for discovering ids or a note on membership scope.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description's 'by id' does tell the agent that membership_id is the lookup key. It adds no detail on the integer format, source, or validation, so it only partially compensates for the missing schema documentation.
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 uses the specific verb 'Get,' names the resource 'compact membership summary,' and qualifies it by 'id.' This clearly marks it as a single-record fetch and distinguishes it from the plural list_project_memberships sibling.
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?
There is no explicit when-to-use or alternative guidance. 'by id' implies usage when the caller has a membership id, but list_project_memberships is never mentioned, so the tool cannot be selected against alternatives with full confidence.
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?
No annotations are provided, so the description carries the full behavioral disclosure burden. It clarifies this is a read-style operation and that the result is the current user's own membership with 'inferred' access hints, adding some context, but it does not explain the meaning of 'inferred access hints' or any limitations/error semantics.
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 a single, front-loaded sentence with no filler. Every word contributes to understanding the tool's core function.
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?
The tool is simple with one parameter and an output schema, so the description need not explain return structure. However, it is incomplete for a tool with no annotations: it lacks guidance on when to use it, what 'inferred access hints' means, and how the project parameter should be supplied, leaving the agent to guess these important aspects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'project' has zero schema description coverage and the description does not add any meaning beyond the schema's title. The tool description mentions 'for a project' but provides no guidance on ID format, project reference type, or required context, failing to compensate for the low schema coverage.
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 tool returns the current user's membership and inferred access hints for a specified project, using a specific verb ('Return') and a specific resource. It differentiates itself from siblings like list_project_memberships and get_current_user by focusing on the current user's project-specific access context.
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 when needing the current user's project access/membership information, but it provides no explicit guidance on when to use this over alternatives like get_membership or list_project_memberships, nor does it mention exclusions or preferred contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only states the basic operation. It doesn't disclose potential errors (e.g., not found), side effects (none), or permissions. Behavioral traits are not addressed.
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 a single concise sentence with no fluff.
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 simple get-by-id operation, the description covers the essential purpose. It doesn't mention return value, but since output schema is present, that's acceptable. It is adequately complete for the given complexity.
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 schema has one required integer parameter, and the description only says 'by id'. It doesn't add meaning beyond the schema's title, so it adds minimal value.
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 operation (get) and resource (time entry) with the identifier as a parameter, effectively distinguishing it from list operations.
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 doesn't explicitly mention when to use this over list_time_entries or other getters, but the 'by id' implies retrieval of a specific resource. Given the naming convention, a user can infer, but explicit guidance would improve it.
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 only states the basic function ('List available... definitions') without revealing whether the list is global or project-specific, whether authentication is required, how results are paginated, or what the response looks like. The description is minimal and does not add behavioral traits beyond the name itself.
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 a single, focused sentence that starts with the verb 'List' and immediately identifies the resource. Every word contributes meaningful context, and there is no redundancy or filler. It is appropriately sized for a tool with zero parameters.
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 zero-parameter, read-only list tool, the description adequately communicates its core purpose and allows correct invocation. However, it lacks explicit disambiguation from related tools such as get_project_phase_definition, and it does not hint at the response format or whether definitions are system-wide or project-scoped. Given the low complexity, the description is nearly complete but could add a phrase to clarify its relationship to phases or definitions.
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 input schema is empty (0 parameters), so there are no parameter semantics to explain. Per the guideline, 0 params results in a baseline of 4. The description does not need to add parameter information, and it correctly implies that invocation requires no arguments.
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 a list operation ('List') targeting a specific resource ('project lifecycle phase definitions'), distinguishing it from sibling tools like get_project_phase_definition (which retrieves a single definition) and list_project_sprints (which lists a different resource). The scope ('available ... exposed by OpenProject') adds useful context.
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 explicit guidance on when to use this tool versus alternatives. It does not mention that this is the tool to enumerate definitions, nor does it suggest using get_project_phase_definition for a specific definition. The only implicit clue is the verb 'list', but no exclusions or alternatives are stated.
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, the description carries the burden of behavioral disclosure. 'List' implies a read-only operation and the provided id clarification adds some context, but there is no mention of what the response contains, whether pagination applies, or any permissions. For a simple list operation, this is minimally adequate but lacks depth.
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 concise and front-loaded with the key purpose. The id note is placed as a separate paragraph, which is helpful but not redundant. It earns a high score for efficiency, though the id explanation could have been integrated more tightly with the main sentence.
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 tool with one parameter and no output schema, the description is nearly complete: it explains the purpose and the only parameter thoroughly. However, because there is no output schema or annotation, additional details about the return shape or behavior would make it more 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 schema only states that work_package_id accepts an integer or string, but the description adds valuable meaning by explaining that it can be an internal id (952) or display_id ('PROJ-51') and explicitly warns 'not UI display number.' This fully compensates for the 0% schema description coverage and ensures correct invocation.
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 attachments on a work package.' The verb 'list' and the resource 'attachments on a work package' are specific. It does not explicitly distinguish it from the similar sibling tool 'list_work_package_file_links', but the core purpose is unmistakable.
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 usage guidance is provided: there is no explanation of when to choose this over list_work_package_file_links or get_attachment, no prerequisites, and no exclusions. The only extra note clarifies the id format, which is parameter semantics rather than tool-selection guidance.
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 is the only source of behavioral information. 'Get' implies a read-only operation, which is generally safe, but the description does not explicitly state side effects, error conditions, or any other behaviors. It is accurate and non-misleading but offers no additional detail, hence a baseline acceptable score of 3.
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 consists of a single, clear sentence that is directly on point. Every word contributes to conveying the tool's purpose. There is no redundancy or wasted text, making it an excellent example of conciseness.
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 simple getter with one required parameter and no nested objects, the description covers the essential functionality. The presence of an output schema means the return value does not need to be described. While it lacks any mention of error handling or edge cases, the low complexity of the tool makes the description adequately complete for its context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has zero description coverage—there is no description for the 'grid_id' parameter. The description 'by id' adds only minimal semantic value, leaving the agent to infer that the ID is an integer. Since the schema does not explain the parameter and the description does not compensate, the score drops below the baseline of 3.
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 uses a specific verb ('Get') and identifies the exact resource ('a single dashboard grid') and scope ('by id'). It clearly distinguishes itself from sibling 'list_grids' by emphasizing 'single', which is exactly what an agent needs to differentiate the two.
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 context for when to use this tool is implicitly clear (when you have a grid ID and want a single result), but there is no explicit guidance on when not to use it or mention of alternatives. Since the sibling tool 'list_grids' is not mentioned, the usage context is only implied. This matches a score of 3 (minimum viable).
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, the description carries the behavioral burden. 'Get the current status' clearly indicates a read operation that returns a snapshot rather than mutating state. However, it does not mention whether the job is removed after retrieval, whether the endpoint is safe to poll repeatedly, or what happens if the job ID is invalid.
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 one sentence, front-loaded with the action, and contains no redundant information. The example adds clarity without bloat.
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 has only one required parameter and an output schema, the description is largely sufficient for an agent to understand the tool's purpose. The main missing context is the origin of job_status_id and any polling semantics, but the simplicity keeps this from being a critical gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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 for the parameter's meaning. The name job_status_id and the tool description imply the parameter identifies the job, but the description never explicitly states that job_status_id is the ID returned when the background job was created, nor does it explain how to obtain or format it.
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 identifies the verb ('Get'), the resource ('status of a background job'), and gives a concrete example ('project copy'). The 'background job' qualifier distinguishes it from sibling tools like get_status, which likely operate on work package statuses rather than job status.
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 example 'such as project copy' implies it should be used to check on asynchronous background operations, which is useful but indirect. It provides no explicit guidance about when to poll, when not to use it, or how it relates to alternatives like get_status.
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 disclosing behavioral traits. It only states 'Get' without clarifying that this is a read-only operation, that it returns a single object, or any potential errors. It does not add context beyond the action itself, leaving behavioral expectations undisclosed.
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 a single, front-loaded sentence with no extraneous words. It immediately states the action and resource, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no nested objects, output schema present), the description is complete enough. It does not need to explain return values since the output schema defines the structure, and there are no complex behaviors or side effects to disclose for a simple fetch-by-id operation.
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?
Schema description coverage is 0% (no descriptions in schema properties), so the description must compensate. The phrase 'by id' clarifies that the sole parameter is the identifier, but it does not elaborate on the id's origin, format, or relationship to other entities. This is minimally sufficient but adds little beyond the parameter name 'phase_definition_id'.
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 uses the specific verb 'Get' with a precise resource ('single project lifecycle phase definition') and explicitly mentions retrieval by id. It clearly distinguishes from sibling tools like list_project_phase_definitions (which lists all) and get_project_phase (which likely retrieves a different entity).
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 when you have a specific phase_definition_id, but it does not explicitly state when to prefer this over alternatives, nor does it mention any exclusions or prerequisites. The guidance is implicit rather than explicit, fitting the 'implied usage' category.
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?
No annotations are provided, so the description is the sole source of behavioral information. It conveys a simple read-only 'get' operation, but does not disclose behavior for nonexistent IDs, permission issues, or error conditions.
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 one short sentence that is front-loaded with the action and resource. Every word earns its place and there is no redundant detail.
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 simple one-parameter getter with an output schema, the description is largely complete. It could mention that the ID must reference an existing wiki page or note access restrictions, but those are not required given the tool's simplicity.
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?
Schema description coverage is 0%, and the description only adds 'by id' without explicitly naming or elaborating on wiki_page_id. The single parameter's title and integer type are self-explanatory, making the minimal description adequate but not enriching.
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 'Get', the resource 'wiki page', and the scope 'single ... by id'. This is specific and distinguishes it from sibling tools that target other resources.
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 phrase 'by id' implies that the tool should be used when a wiki page ID is already known, but there is no explicit when-to-use versus alternatives guidance or exclusionary context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses pagination behavior: the limit is capped at OPENPROJECT_MAX_PAGE_SIZE (default 50) and how to page using next_offset. This adds meaningful behavioral context beyond the schema. It does not mention auth or return structure, but the disclosed details are valuable.
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 two sentences, with the primary purpose in the first sentence and essential pagination details in the second. It is front-loaded and concise, with no extraneous text.
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?
With no output schema and no annotations, the description should explain all parameters and behavior. It covers pagination and basic scope but omits search semantics, project parameter format, and any indication of the return structure. For a moderately simple list tool, this is adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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 mentions limit and offset in the pagination note (though not explicitly naming 'offset' except as next_offset), but search and project parameters are not explained at all. The description adds partial value but fails to clarify all parameter semantics, especially search and project.
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 tool lists saved OpenProject boards/queries with optional project scoping. It uses a specific verb ('list') and resource ('boards/queries'), distinguishing it from sibling tools like get_board (single) and list_grids (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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (listing boards, optionally scoped to a project) but does not explicitly contrast with alternatives like get_board or list_grids, nor does it state when not to use this tool. No exclusions are provided, so guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It reveals the required-filter constraint, the pagination cap, and how to page via next_offset. It does not mention authentication or output details, but the core behavioral traits are disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short paragraphs, front-loaded with the core purpose, and every sentence adds value. The pagination and filter constraints are presented efficiently without repetition or filler.
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, the description covers the critical invocation constraints: required filters, the no-global-listing rule, and pagination. There is no output schema to lean on, and the description only hints at the return shape via next_offset, but an agent has enough to call the tool correctly.
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?
Schema description coverage is 0%, so the description must compensate. It meaningfully explains limit and offset behavior and the requirement for project/capability_id. However, it does not clarify the expected value formats or the relationship between project and capability_id, leaving some parameter semantics under-specified.
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?
States a specific verb and resource ('List API capabilities exposed by OpenProject') and is immediately understandable. It does not explicitly differentiate from similar sibling tools like list_actions or list_roles, but the resource scope is clear enough for an agent to identify the tool's purpose.
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?
Provides important invocation guidance: at least one of project or capability_id is required, and explains why unfiltered listing is not allowed. However, it does not say when to prefer this tool over alternatives, so usage context is only implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It clearly indicates a read-only listing operation, but it does not disclose any additional behavioral details such as response format, sorting, or whether it includes all fields. However, for a simple list tool, this might be sufficient.
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?
A single, short sentence that is perfectly concise and front-loaded with the purpose.
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 tool with no parameters and no output schema, the description is complete enough. It states the action and scope ('all available') without needing extra detail. It could mention the response format, but it's a simple list tool.
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 tool has zero parameters, and schema coverage is 100% (trivially). The description adds nothing beyond the schema because there are no parameters to explain. Baseline for high coverage is 3.
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 action and resource: 'List all available work package priorities.' It uses a specific verb and resource, and it distinguishes from siblings like get_priority by indicating it lists all priorities rather than fetching a specific one.
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 tool's purpose is obvious from the name and description, but it does not explicitly mention when to use it over alternatives like get_priority. The usage context is implied, but no explicit guidance on choosing between tools is provided.
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 only states that it lists watchers, with no mention of side effects, authentication requirements, pagination, or read-only nature. This is a minimal disclosure for a list operation, lacking any extra 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 extremely concise, with two sentences, and front-loads the action. The parameter clarification is presented immediately after the main statement, making it easy to scan. Every word adds value, with no filler.
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 simplicity (one parameter, no output schema), the description is adequately complete. It covers the essential purpose and parameter semantics. However, it does not mention what the response contains or if there are any special behaviors like pagination, but this is minor given the straightforward nature of the operation.
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 only provides a generic 'work_package_id' parameter with anyOf integer/string, but the description adds crucial guidance: it accepts either an internal id (e.g., 952) or display_id (e.g., 'PROJ-51'), and clarifies that the UI display number is not used. This meaningfully improves parameter understanding beyond the raw 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 action ('List') and the resource ('watchers of a work package'). It distinguishes from sibling tools like list_work_package_attachments and list_work_package_file_links by specifying the exact resource. The verb-resource combination is unambiguous.
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 implicitly suggests this tool is for retrieving watchers of a work package, but it does not explicitly state when to use it versus alternatives or provide any exclusion criteria. Since there are no direct sibling tools for watchers, the implied usage is acceptable, but the lack of explicit context keeps it at a 3.
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 disclosing behavior. It does reveal key behavioral aspects: the tool returns reminders scoped to the current user and filters for active ones, which implies a read-only, personalized query. However, it does not mention edge cases like empty results, pagination, or any side effects, and the phrase 'current user' indirectly suggests authentication but this is not explicit. The description provides adequate but not extensive transparency.
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 a single, well-structured sentence of eleven words, front-loading the main verb and object without any unnecessary modifiers or repetition. It conveys resource, scope, and filtering in a highly efficient manner, embodying ideal conciseness.
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?
The tool is simple (zero parameters, no output schema), and the description covers the essential scope: current user, active reminders, all work packages. However, it does not mention the return format, sorting, or pagination, nor does it describe what happens when there are no reminders. While probably sufficient for most use cases, the lack of any return-value or error-behavior details makes it only moderately complete, meriting a score above the minimum but below what a richer description could achieve.
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 takes zero parameters and the input schema is an empty object (100% schema coverage). According to the guidelines, a zero-parameter tool receives a baseline score of 4 because there is no parameter information to convey. The description does not conflict with the empty schema and accurately adds no extra parameter-related detail.
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 uses a specific verb 'list' and precisely identifies the resource as 'the current user's active reminders' with the scope 'across all work packages.' This makes it immediately clear what the tool does and distinguishes it from sibling tools like 'list_work_packages' or 'list_actions,' none of which mention reminders. The singular focus on the current user and active status adds useful specificity.
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 for retrieving reminders belonging to the authenticated user and filters for active ones, but it does not explicitly state when to use this versus an alternative tool or provide exclusions. No mention is made of alternatives (e.g., searching by work package) or when not to use it, leaving the usage context partially implicit.
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?
No annotations are provided, so the description carries the burden. It clearly indicates the operation is a read-style 'List' action, and it warns about the identifier type. However, it does not mention return structure, pagination, access requirements, or any other behavioral details beyond the basic operation.
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 minimally sized: one clear sentence describing the action and one supplementaryentence explaining the identifier format. It front-loads the primary purpose and includes no fluffer or repeated computational details.
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?
The tool is simple, with one parameter and no output schema, and the description covers what the tool does and how to pass the ID. However, it does not describe what the result list contains (e.g., URLs, file namements) or any potential limits, which is a noteworfor only a basic list tool.
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 only provides a type union of integer or string, so the description adds significant value by detailing that work_package_id accepts an internal id like 952 or a display_id like 'PROJ-51', and that the UI display number should not be used. This directly compensates for the 0% schema description coverage.
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 states exactly what the tool does: 'List Nextcloud file links attached to a work package'. It includes a specific resource and action, and the 'Community Edition' qualifier helps scope it. This distinguishes it from sibling tools like list_work_package_attachments and list_work_package_watchers.
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 gives toolurpose and a note about the edition, but it does not explicitly explain when to use this tool versus other list tools such as list_work_package_attachments. There are no when-not-to-use conditions or alternative tool references, so the usage context is implied rather than spelled out.
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?
No annotations are provided, and the description only says 'get' which implies a read operation without detailing side effects, return behavior, or error handling. Minimal transparency.
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 a single concise sentence with no redundant words, perfectly scoped to the operation.
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 simple get operation, the description is complete in stating what it does. It does not explain return format, but that is likely covered by the output schema. Missing explicit notes on errors or limitations, but acceptable for a basic retrieval.
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 single parameter view_id is explained as 'id' in the description, which conveys that it is the identifier for the view. While minimal, it provides enough meaning given the schema context.
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 action (get) and the resource (a single OpenProject view) by id, distinguishing it from list_views and other get_* tools.
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 for retrieving a specific view by ID but does not explicitly contrast with alternatives like list_views or mention when to prefer this tool over others.
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?
No annotations exist, so the description carries the full burden. It clearly signals a read operation with 'Get', but it does not disclose not-found behavior, authentication needs, or response error details. Adequate for a simple getter, but minimal.
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?
A single front-loaded sentence with no filler. Every word contributes to purpose, scope, and parameter semantics.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/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 required parameter, no annotations), and the presence of an output schema that documents return values, this description is sufficient for an agent to select and invoke the tool. No additional context seems necessary.
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 does so by mapping phase_id to the target entity via 'by id', giving the parameter meaning as the identifier of the phase. However, it does not specify where the id comes from or any constraints beyond the schema's integer type.
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?
Description states 'Get a single project lifecycle phase by id' with a specific verb, resource, and scope. It clearly distinguishes from sibling tools like get_project_phase_definition and list_project_phase_definitions by emphasizing 'single' and 'by id'.
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?
No explicit when-to-use or alternative guidance is provided. The intended usage is implied: use when you need a specific phase by its id. It does not contrast with the related get_project_phase_definition tool, which could be confused with this one.
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?
No annotations are provided, so the description carries the burden. It states that the result is a 'compact project summary', which hints at the response being a summary rather than full details. However, it doesn't disclose if this is a read-only operation, any authentication needs, or what happens if the project is not found. For a simple read operation, the description is adequate but could add more behavioral context (e.g., success/failure behavior, related data included). This is a reasonable middle score considering the simplicity.
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 extremely concise: two sentences with zero waste. The first sentence states the core purpose, and the second provides parameter usage details. It is front-loaded with the most important information. This is a model of efficiency.
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?
The tool is simple (one required parameter) and has an output schema, so the description doesn't need to explain return values. The description covers the purpose and parameter semantics. It might benefit from mentioning what 'compact' means or if there are any typical use cases, but given its simplicity, this is largely complete. The only gap is behavioral transparency around error conditions, but that's minor. This is above average.
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 has a single parameter 'project' with no description (coverage 0%), so the description must add meaning. It does so effectively: it explains that 'project' can be a numeric id (e.g., 7) or an identifier (e.g., 'my-project'), and explicitly states it is not a display name. This adds crucial semantic detail that the schema lacks. Given the low coverage, this is very helpful and earns a 4.
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 tool's purpose: 'Get a compact project summary by id or identifier.' It specifies the resource (project) and the action (get), and the input method distinguishes it from sibling tools like list_projects (which lists projects) and get_project_configuration (which retrieves configuration). The phrase 'compact project summary' sets clear expectations.
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: it explains that the parameter can be a numeric id or identifier, and explicitly notes what it is not (not the display name). While it doesn't name alternative tools or explicitly say when not to use this, the guidance is clear enough for an agent to select this tool when wanting a project summary by id. It also differentiates from list_projects implicitly. No exclusions or alternatives are mentioned, which prevents a 5, but this is high quality.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the transparency burden. It discloses critical behavioral traits: the limit cap (OPENPROJECT_MAX_PAGE_SIZE), pagination via next_offset, the meaning of 'total' as per-page count only, and early termination of search. This goes far beyond typical list tool descriptions and is essential for correct invocation.
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, using a short first sentence for purpose and a second paragraph for pagination details. Every sentence contributes value, with no redundancy. It is well-structured and front-loaded, 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.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explains behavior thoroughly, including pagination and count limitations. It doesn't specify the return structure or error cases, but for a list tool with moderate complexity, this is sufficient. The provided details are complete enough for safe invocation.
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 coverage is 0%, so the description must clarify parameters. It explains 'limit' is capped, 'offset' should be set from next_offset for pagination, and 'project' filters results. These insights add meaning to all three parameters, though it doesn't restate types or defaults (already in 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 first sentence explicitly states the action (list) and resource (documents) with an optional filter by project. This clearly distinguishes it from sibling tools like list_grids or list_categories, which target different resource types.
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 mentions 'optionally filtered to a single project' but does not provide guidance on when to use this tool versus alternatives (e.g., get_document for a single document). No exclusions or alternative recommendations are given, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It does well by revealing non-obvious behavior: relation types are canonicalized at creation, filtering matches the stored canonical type, and from_id/to_id can be swapped. It also discloses the page-size cap and next_offset pagination behavior, which are important operational traits.
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 and then packs each sentence with non-obvious, high-value details: canonicalization, type-match semantics, and pagination. No sentence is filler or redundant with the schema.
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 simple schema and absence of annotations, the description covers the most important operational context: instance scope, optional filtering, canonical-type handling, and paginated listing. It could be slightly more complete by explicitly mentioning the shape of the returned relation objects, but the mention of type/from_id/to_id and next_offset provides enough for most usage.
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?
Despite having 0% schema description coverage, the description compensates well: relation_type is explained with examples and canonical-type semantics, limit is explained as capped at OPENPROJECT_MAX_PAGE_SIZE, and offset is tied to the returned next_offset. This adds strong practical meaning beyond the raw schema types.
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 opens with a specific verb and resource: 'List all relations across the instance, optionally filtered by type.' This clearly establishes scope and function, and unlike the sibling get_work_package_relations, it signals instance-wide behavior rather than a single work package's relations.
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 provides strong context about instance-level listing and pagination, but it does not explicitly explain when to prefer this tool over alternatives or when not to use it. The distinction from get_work_package_relations is implied by 'across the instance,' but no alternative tool is named or contrasted.
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?
No annotations are provided, so the description carries the transparency burden. It discloses the visibility constraint ('visible to the current user'), but does not mention return format, pagination, or potential empty results. For a simple listing tool this is adequate but not rich.
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 a single, front-loaded sentence with no filler. It states the action, resource, and scope efficiently.
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 zero-parameter listing tool, the description is largely complete: it names the resource and scoping. The lack of output schema means return behavior is not specified, but this is not critical for such a simple list operation.
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 zero parameters, so the schema already fully conveys parameter semantics. The description needs to add no parameter detail, and the baseline of 4 is appropriate.
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 uses a specific verb and resource ('List OpenProject roles') and adds a clear scope ('visible to the current user'). It is distinct from sibling tools, none of which target roles.
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 implies this tool is for retrieving roles accessible to the current user, which gives clear context. There are no explicit exclusions or alternative suggestions, but with no overlapping role-related siblings this is acceptable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
While no annotations are present, the description compensates by disclosing critical behavioral details: the meaning of 'total' (page-limited), the early-termination optimization, and the necessity to page via 'next_offset'. This goes beyond the bare minimum, though it could still explain error cases or rate limits. However, the substantial page-walk disclosure deserves high marks.
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?
Every sentence earns its place. The description front-loads the purpose, then dedicates a dense but readable paragraph to pagination gotchas. No fluff, no repetition, and it stays focused on what's not obvious.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with rich parameters and no output schema, the description covers the critical context: parameter meanings, pagination, and value semantics (total). The only missing piece is clarifying the remaining undocumented params, but the complexity is high and the description handles the hardest parts well.
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 coverage and 7 parameters, the description carries the full burden. It clarifies 'work_package_id' (internal vs display ID), 'limit' (capped at OPENPROJECT_MAX_PAGE_SIZE), and 'offset' (use next_offset). It misses explaining 'spent_on_from', 'spent_on_to', 'user', and 'project' formats, so it's not perfect, but what's covered is explained precisely.
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 opens with a clear statement: 'List time entries with optional project, work package, user, and date filters.' It uses a specific verb and resource, and the mention of filters helps distinguish it from sibling tools like 'get_time_entry' (singular). However, it doesn't explicitly name a sibling as an alternative, so it falls short of 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly communicates usage via the filtering capability and pagination workaround. However, it doesn't explicitly state when to use this over alternatives or give exclusions. The alternative to use for filtered searches is implied but not named, so it misses the 'explicit alternative' bar.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 adds a valuable read-only warning: types cannot be created or modified via the OpenProject API and are configured in the web admin UI. This goes beyond a simple list statement, though it omits details like authentication requirements or pagination.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: the first sentence states the core purpose and filtering capability, and the second provides an important behavioral caveat. Every sentence earns its place 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?
This is a relatively simple tool with one optional parameter and no output schema. The description covers the main purpose, filtering behavior, and an important read-only constraint. It is sufficiently complete for an agent to select and invoke the tool correctly, though it could mention return format or project identifier specifics.
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 input schema provides only a project string field with 0% description coverage. The tool description compensates by explaining that the project parameter is an optional filter, giving semantic meaning that the schema alone lacks. It does not specify the expected format of the project identifier, so it is not a perfect 5.
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 tool lists 'all available work package types' with an optional project filter. This is a specific verb+resource combination and distinguishes it from sibling tools like get_type, which fetches a single 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 when to use this tool (to list types) and provides the context that types are read-only via the API and must be configured in the web admin UI. However, it does not explicitly mention alternatives or when not to use it, such as whether to prefer get_type for a specific type lookup.
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?
The word 'Return' implies a read-only operation, which is useful since no annotations are provided. However, the description does not disclose auth requirements, response shape, or whether the operation is safe to call repeatedly; for a zero-parameter getter, this is acceptable but not deeply transparent.
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 a single, front-loaded sentence that contains no filler and every word contributes meaning. It is appropriately concise for a simple getter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no parameters, an output schema available, and the description naming precisely what is returned, the description is sufficient for an AI agent to understand and invoke the tool correctly. The ambiguity with project-level config is already mitigated by the 'instance-level' qualifier.
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 accepts zero parameters, so the schema already fully covers parameter semantics. The description adds the useful context that the output is instance-level configuration and active feature flags, which is sufficient for a no-parameter operation.
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 a specific action ('Return') and a specific resource ('instance-level OpenProject configuration and active feature flags'). It also distinguishes this from sibling tools like get_project_configuration, which target project-level config.
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 term 'instance-level' gives clear context that this is for global/system-wide configuration rather than project-scoped data. However, it does not explicitly name alternatives or state 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the transparency burden. It states it's a list operation (implying read-only) but doesn't explicitly mention side effects, error conditions, or whether all actions are returned. Given the minimal nature, it's adequate but not fully transparent.
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 two concise sentences that cover the tool's purpose and pagination details without any redundancy or fluff. It is well-structured 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?
There is no output schema, so the description must hint at the return structure. It mentions `next_offset`, suggesting the response includes a pagination token, but doesn't describe the full response format. Given the simplicity of a list operation, this is sufficient, though slightly more detail would be helpful.
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 meaning to the parameters: it explains the `limit` cap and default, and how `offset` should be used with `next_offset` for pagination. This goes well beyond the schema's simple type/default definitions, fully clarifying the intended usage.
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 'List API actions exposed by OpenProject.' This provides a specific verb (list) and resource (API actions), and distinguishes it from sibling tools that list specific resources like grids, categories, or projects.
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 explains pagination behavior ('limit is capped at OPENPROJECT_MAX_PAGE_SIZE (default 50); pass the returned next_offset as the next call's offset') which indicates when to use it (to enumerate all actions) and how to handle large result sets. It doesn't explicitly contrast with alternatives, but the purpose is clear enough.
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?
No annotations are provided, so the description carries the full burden. It clarifies the parameter format (internal ID vs display ID) but does not disclose behavioral details such as pagination, response structure, required permissions, or whether reactions are aggregated per comment or globally. This is a basic read-only tool, so the missing details are not critical but leave some 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 two sentences: the first states the purpose, and the second explains the only parameter. It is front-loaded, concise, and every sentence earns its place with no redundancy.
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 simple one-parameter list tool with no annotations and no output schema, the description adequately covers the primary use case and parameter semantics. It could mention response content or limitations, but the low complexity makes the description sufficient for an agent to select and invoke the tool correctly.
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 schema only provides a bare anyOf integer/string with zero description coverage. The description adds crucial meaning by explaining work_package_id can be an internal id (e.g., 952) or display_id (e.g., 'PROJ-51') and explicitly notes it is not a UI display number. This fully compensates for the schema's lack of description.
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 tool lists emoji reactions across a work package's comment activities, using the specific verb 'List' and resource 'emoji reactions'. It distinguishes itself from sibling tools that handle file links, watchers, or activities.
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 implies this tool is used when you need emoji reactions for a work package's comments, which is clear from the purpose. It does not explicitly name alternatives or when-not-to-use, but the context is sufficiently clear given the sibling tool names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses critical behavioral details: the limit is capped at a server-defined maximum, pagination uses next_offset, and the 'total' field is misleading (only counts the current page and may stop early). This is significant transparency beyond the schema, helping the agent manage pagination and interpret results correctly.
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 two concise sentences. The first states the purpose, and the second provides essential pagination details. Every word earns its place; there is no fluff or redundancy.
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 simple list tool with no output schema and no annotations, the description covers the key behavioral aspects: pagination, limit cap, and total's meaning. It also clarifies the project identifier format. It could be more complete by describing the returned sprint object structure or mentioning any required permissions, but given the tool's simplicity, it is reasonably complete.
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 schema has 0% description coverage, so the description must explain parameters. It implies meaning for limit (capped, used for pagination) and offset (passed via next_offset), but it does not explicitly define them or explain that limit is the page size and offset is the starting index. The 'project' parameter is clarified as 'id or identifier' in the first sentence. Overall, it adds some value but does not fully compensate for the lack of schema documentation.
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 tool lists Backlogs sprints for a project by id or identifier. It uses a specific verb, object, and scope that distinguishes it from sibling tools like list_sprints (which likely lists all sprints) and get_sprint (which fetches a single sprint). The purpose is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: it is for a specific project, identified by id or identifier. It does not explicitly mention alternatives like list_sprints, but the project scoping is implicit. It also gives practical usage guidance on pagination, explaining how to page through results. However, it lacks an explicit 'when not to use' statement, so it doesn't fully guide selection among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/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 explains canonicalization of relation types (precedes stored swapped), that from_id/to_id reflect stored state not the query, and the pagination cap with next_offset. This is thorough and adds significant value.
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 reasonably concise, front-loaded with purpose, but includes somewhat dense technical explanation. Could be slightly cleaner but each sentence adds value.
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 no annotations and no output schema, the description covers important behavioral nuances (canonicalization, pagination). It might miss explicit return structure, but for a list endpoint it's acceptable. Also mentions the relation types. Complete enough.
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 has 0% description coverageerver, but the description compensates well: it explains work_package_id accepts internal id or display_id (with example), and explains limit cap and offset pagination. It doesn't explicitly explain offset parameter, but conveys its use via next_offset. Good compensation.
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 tool retrieves all relations for a work package, listing relation types (blocks, relates to, duplicates). It distinguishes from siblings like list_relations by specifying it's scoped to a specific work package. The verb 'Get' and resource 'all relations for a work package' are specific.
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?
Provides detailed guidance on parameter usage (work_package_id accepts internal or display ID, not UI display number). Mentions the pagination mechanism with next_call offset. However, it does not compare to sibling tools like list_relations or state when to prefer one over the other, so it lacks explicit alternatives/exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It explicitly explains ordering (most recent first), comment truncation behavior, how to widen the cap via text_limit, and the fields indicating truncation. This is transparent and useful.
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 compact and every sentence adds value. It is front-loaded with the primary purpose, followed by two clarifying sentences—no fluff.
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 no output schema, the description explains key output fields (comment_truncated, comment_length) and ordering. It could go further by describing the general structure of the activity log, but it is sufficiently complete for a simple getter tool.
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?
Adds significant meaning beyond the schema: explains that work_package_id accepts internal or display ID, and describes the effect of text_limit. However, the limit parameter is not mentioned, leaving a minor gap.
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 tool's purpose: "Get the activity log for a work package, most recent first." This uses a specific verb and resource, distinguishing it from sibling tools like get_work_package or get_work_package_relations.
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?
Provides useful context on when to use the tool (to retrieve activity logs) and clarifies important parameter semantics like ID formats. However, it does not explicitly exclude alternatives or state when not to use it, though the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does well: it mentions parallel fetching, per-item failure reporting without stopping the batch, deduplication of IDs, and that id/success/error fields are always included. It also warns about size limits and redirection to a file for large batches. Minor gaps like auth requirements or rate limits are not covered, but for having no annotations, this is strong.
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 with a leading summary, followed by behavior, parameters, and a warning. Every sentence adds value—no fluff. It front-loads the core purpose and then details constraints and pitfalls. The paragraph breaks improve readability. This is efficient and thorough without being verbose.
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 no output schema, the description explains what results look like (per-item success/error, id/success/error always included), which is important. However, it lacks details on the exact structure of returned items beyond the always-included fields, error handling specifics beyond 'reported individually', and does not clarify whether text_limit applies to select fields. As a tool that returns batch results, this is a minor gap.
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 coverage is 0%, so the description must fully explain parameters. It explains 'ids' (accepts internal or display IDs, not UI numbers, deduplicated), 'select' (restricts fields, invalid names return allowed set), and 'text_limit' (mentioned as a mitigation for large batches). However, the text_limit description is sparse and lacks specifics on what it limits (e.g., character count per field) and how it interacts with select.
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 'Get multiple work packages by ID in a single batch call', specifying the verb (get), resource (work packages), and scope (batch). It distinguishes from sibling tools like get_work_package (singular) and list_work_packages (list semantics) by emphasizing batch retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Get multiple... by ID in a single batch call') and provides critical usage guidance such as maximum 100 IDs per batch, ID formats (internal vs display, not UI numbers), and a warning about large batches. It implies this is for known IDs, contrasting with search/list tools, but does not name alternatives explicitly. The detailed constraints and the proactive advice about text_limit/select give clear usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and delivers extensive behavioral detail: limit is capped at OPENPROJECT_MAX_PAGE_SIZE, next_offset should be used for pagination, total reflects only the current page, and the search may stop early. This goes well beyond a simple list and clarifies important edge 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?
The description is concise and well-structured: a one-sentence purpose followed by a focused paragraph on pagination behavior. Every sentence provides useful information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description covers the essential aspects: what the tool lists, how filtering works, and how pagination behaves. It also explains the non-obvious total semantics, which is critical for correct usage.
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 input schema has no descriptions (0% coverage), so the description must compensate. It explains limit's cap, offset's role in pagination via next_offset, and scope as a page-path filter, giving meaningful context for all three parameters.
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 'List dashboard grids' with an optional scope filter by page path, which is a specific verb+resource combination. This distinguishes it from sibling tools like get_grid (singular) and list_views/list_boards by naming the grid resource explicitly.
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 provides pagination instructions but does not explicitly state when to use this tool over alternatives such as get_grid or list_views. Usage is implied by the tool name and purpose, but no when-not or alternative guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description fully bears the burden of transparency. It discloses key behavioral traits: the limit cap (OPENPROJECT_MAX_PAGE_SIZE), the meaning of 'total' (only page count, not all matches), the early termination of search, and the explicit pagination mechanism via next_offset. These are non-obvious and crucial for correct usage, going beyond typical descriptions.
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: first sentence states the primary purpose, followed by a detailed paragraph on pagination and total semantics. No redundant wording; every sentence adds value. The information is front-loaded and the technical details are organized logically.
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?
The tool involves pagination and subtle total behavior, which the description explains thoroughly. It does not describe the structure of returned news entries, but no output schema exists, so it might be inferred or expected. It also does not mention permissions or side effects, but as a list tool (read-only) this is likely not necessary. Overall, it is complete for the core usage, with minor gaps in return structure and explicit authorization requirements.
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 coverage is 0%, so the description must compensate. It explains the 'filtered by project or title/summary search' which maps to 'project' and 'search' parameters, and details limit and offset semantics including the cap and offset progression. It adds meaning beyond the schema by clarifying the limit's cap and the offset's role in pagination, though it doesn't elaborate on search syntax or project format.
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 that it lists news entries with optional filters for project and search (title/summary). It uses a specific verb 'List' and resource 'news entries', distinguishing it from sibling tools like get_news (single entry) and list_boards (different resource). It is unambiguous and provides the essential purpose.
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 gives clear context on when to use the tool: for listing news with optional filtering. It implicitly differentiates from get_news by focusing on list functionality. However, it does not explicitly mention alternatives or when not to use it (e.g., if you need a single news entry, use get_news). The pagination guidance is useful and gives usage direction, but lacks explicit exclusionary language.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations present, so the description bears full responsibility. It discloses key behaviors: result cap (limit capped at OPENPROJECT_MAX_PAGE_SIZE), non-standard total behavior (not a full count), and specific pagination instructions. This is exactly the kind of behavioral nuance that isn't obvious from 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, front-loaded with the purpose then details. It's compact but dense with important information. No fluff. Slightly long but justifies it with crucial pagination/total caveats.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description provides complete guidance: what it returns (total caveat), how to page, and parameter semantics. For a list tool with 4 optional params and no output schema, this is well-rounded and sufficient.
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 explains limit (capped, page size), search (case-insensitive substring), and project (context for the search stop). Offset is implied via next_offset. Given these explanations, it adds significant meaning beyond bare parameter names.
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?
Clear verb+resource with explicit scope: 'List versions globally or for a specific project, optionally filtered by a case-insensitive name substring.' It provides the two main dimensions of filtering (project and search), distinguishing it from sibling list tools like list_grids or list_projects.
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 explains when to use the tool and how to paginate: 'Page until next_offset is null.' It also states the limitation without project. However, it doesn't explicitly name alternative tools or provide when-not-to-use guidance, though the context suggests it for listing versions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the burden of behavioral disclosure. It explicitly explains the limit cap, the meaning of next_offset for pagination, the non-exhaustive total (only page count), and the early termination of the search. This is critical information an agent needs to use the tool correctly and interpret results properly.
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 purpose, and the additional sentences about pagination are concise and necessary. It is not overly verbose; each sentence adds important detail. The only minor structural issue is that the pagination paragraph could be integrated into the first sentence for even more brevity, but it remains well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/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 (pagination, non-obvious return semantics) and the absence of an output schema, the description is remarkably complete. It explains exactly how pagination works, what the total shows, and how to traverse all results. It covers all aspects an agent needs to invoke the tool correctly and interpret the response.
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?
Since schema description coverage is 0%, the description must compensate. It explains that 'project' filters by project and 'type' filters by view subtype, and it clarifies the semantics of 'limit' and 'offset' through the pagination discussion. However, it does not specify acceptable values for project or type, leaving some ambiguity, but the core meaning is conveyed.
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 it lists saved OpenProject views with optional filtering by project or subtype. This distinguishes it from sibling tools like list_grids and list_categories, which focus on different resources.
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 gives clear context for when to use this tool (when listing saved views) and explains pagination behavior, but it does not explicitly mention when not to use it or name alternative tools. The context is clear enough, though it lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/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, and it delivers comprehensively. It reveals non-obvious behaviors: limit capping, total/next_offset semantics under restricted visibility, assignee_me precedence, version_status allowed values, and parent_display_id being version-dependent. It even warns about the counterintuitive total=0 with non-null next_offset case and instructs the agent to keep paging.
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 long but carefully organized into focused paragraphs, each covering a distinct behavior or parameter group. It front-loads the core purpose and then systematically walks through filters, sorting, grouping, selection, and pagination. Given the tool's 20 parameters and 0% schema coverage, the length is justified and every paragraph earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list operation with no annotations and no output schema, the description is exceptionally complete: it covers filtering, sorting, grouping, field selection, pagination, and security-aware total semantics. It also provides concrete edge-case handling, such as continuing to page when total reads zero. An agent has enough information to call the tool correctly, interpret results, and avoid common pitfalls.
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 schema description coverage at 0%, the description must compensate, and it explains the semantics of nearly all 20 parameters: project formats, status/priority exact matching, date filter inclusivity, sort_by syntax, group_by fields, select behavior, and paging. The only notable omission is the `type` parameter, which appears in the schema but is never explained as a filter in the description. Despite that gap, the parameter-level guidance is far beyond typical descriptions.
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 first sentence states a specific verb and resource: 'List work packages with structured filters and no free-text query requirement.' This immediately distinguishes the tool from a search-oriented sibling and makes its scope unmistakable. The rest of the description reinforces this by detailing the available filter categories.
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 frames this as the correct tool for structured filtering and says it has 'no free-text query requirement,' which guides an agent away from free-text search tools. It also provides clear instructions for paging via next_offset and explains when total is meaningful. However, it does not explicitly name sibling tools like search_work_packages or list_my_open_work_packages as alternatives, so some contrast relies on the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/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 discloses that the full description is returned by default, explains the text_limit parameter's effect, and describes the truncation-related fields (description_truncated, description_length). This is rich behavioral detail.
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 compact and front-loaded with the primary purpose. Each sentence adds necessary detail (id formats, truncation behavior) without redundancy or fluff. It is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers everything an agent needs: id type ambiguity, default return behavior, and optional text_limit semantics. Since an output schema exists, return values need not be explained. The tool is well-specified for correct invocation.
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?
Schema coverage is 0%, meaning the schema provides no descriptions. The description compensates fully by explaining both parameters: work_package_id (internal or display_id, not UI display number) and text_limit (capping behavior, truncation flags). This adds significant meaning beyond the raw 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 tool retrieves a single work package by id, with a direct verb ('Get') and resource ('work package'). It also distinguishes from siblings like list_work_packages and search_work_packages by emphasizing the singular nature and the id field.
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 on when to use the tool (you have a specific work_package_id) and clarifies which id values are accepted, even referencing sibling tools for id format. It lacks an explicit 'use this instead of X' but the context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Even though no annotations are provided, the description is exceptionally transparent about the tool's behavior, especially around pagination and project scoping. It candidly discloses a security-relevant subtlety: 'total always falls back to this page's item count... so nothing here ever reveals how many matches exist in projects you can't see.' This goes far beyond a typical description.
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 dense but efficient. The first sentence states the purpose, and the rest explains non-obvious pagination and scoping behavior. Every sentence earns its place; no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a filtered list tool with no output schema and no annotations, the description fully compensates. It explains the tool's limits, the meaning of total, next_offset, and truncated under various scopes, and gives a stop condition for pagination. There's nothing missing for an agent to correctly invoke and interpret results.
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?
Schema description coverage is 0% because the input schema only has param names and types, no descriptions. The description explains the critical semantics of 'limit' (capped at OPENPROJECT_MAX_PAGE_SIZE) and 'offset' (use next_offset for pagination). This adds substantial meaning beyond the bare schema definitions.
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 the current user's open assigned work packages' with a specific verb and resource. It also implicitly distinguishes itself from siblings like list_work_packages and search_work_packages by focusing on the current user's open assigned items. However, it doesn't explicitly name an alternative tool, so it falls just short of 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 Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance around pagination: 'limit is capped at OPENPROJECT_MAX_PAGE_SIZE (default 50); pass the returned next_offset as the next call's offset to page past the cap.' It also explains the behavior under restricted scopes and instructs to 'Page until next_offset is null either way,' which tells when to stop using the tool's output. This is excellent, actionable guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full transparency burden and does so exceptionally well. It discloses the limit cap, next_offset-based pagination, projection behavior, invalid select handling, and the subtle total-count semantics under restrictive OPENPROJECT_READ_PROJECTS, which is exactly the kind of behavioral nuance agents need.
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, then logically organized into select semantics and pagination/total-count details. No sentence is wasted; even the env-specific caveats earn their place by preventing misinference.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description covers the essential return semantics: result row fields, total, and next_offset. It also addresses permission-related behavior and pagination edge cases, making it sufficiently complete for an agent to invoke and page through results correctly.
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?
Schema description coverage is 0%, so the description fully compensates by explaining all four parameters: search by name/identifier, select with field examples and invalid-name behavior, limit capped at OPENPROJECT_MAX_PAGE_SIZE, and offset used with returned next_offset. This adds substantial meaning beyond the raw 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 opens with a specific verb and resource: 'List visible projects with optional name or identifier search.' This clearly distinguishes list_projects from the many get_* and list_* siblings by narrowing scope to visible projects and indicating its searchable fields.
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 gives clear context for when to use the tool—listing visible projects, optionally with name/identifier search—and explains key behaviors like pagination and select. It does not explicitly name alternatives or exclusion criteria, but the purpose is specific enough that a capable agent can infer appropriate use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully carries the behavioral burden. It discloses the module requirement, the limit cap, the meaning of total (page count only), and early termination behavior—all beyond what a simple 'list' implies.
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 but information-dense. Each sentence adds value: purpose, prerequisite, pagination details, and total semantics. It is well-organized and front-loaded with the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately covers return values (total, next_offset) and pagination. It covers key usage context and edge cases (module requirement, page stopping), making it complete for a list-with-pagination 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?
Schema coverage is 0%, so the description must compensate. It explains limit's cap and default, and offset's role in pagination via next_offset, giving meaningful semantics for both parameters.
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 'List' and resource 'Backlogs sprints' with scope 'visible to the current token.' It distinguishes from siblings like get_sprint and list_project_sprints by indicating a global, token-scoped listing.
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 a prerequisite (OpenProject Backlogs module) and explains pagination behavior. However, it does not explicitly name alternative tools like list_project_sprints, so the agent must infer when this global listing is preferred over a project-specific one.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explicitly states that the operation is read-only and that statuses cannot be created or modified via the API, providing clear behavioral expectations. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and to the point, conveying all necessary information without extraneous content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description fully covers what the tool does, its read-only nature, and where to manage statuses, making it complete for an agent to decide and use the 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 input schema has no parameters, so the description does not need to elaborate on parameter meanings. The absence of parameters is consistent with the description.
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 that the tool lists all available work package statuses, which is a specific and distinct action. It differentiates from sibling tools by focusing on statuses.
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?
It implies when to use the tool (when needing to retrieve statuses) and explicitly notes that statuses cannot be modified via API, directing configuration to the web admin UI. It does not explicitly mention alternatives, but the scope is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/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—and it delivers extensively. It discloses the exact_match parallel resolution, its absence conditions, the total/count/pagination fallback behavior for restricted scopes, the security reason behind it, and version-dependent parent_display_id 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?
Although long, the description is efficiently structured: a clear opening purpose, then logically grouped parameter semantics, scoping rules, pagination caveats, and field nuances. Every sentence adds operational value, and critical limitations like exact_match and total fallback are front-loaded enough to prevent misuse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 18-parameter tool with no output schema and no annotations, this description is remarkably complete. It covers match behavior, filters, date handling, sorting, grouping, selection, pagination, total fallback, scope restrictions, and even OpenProject version differences—leaving no significant gap for safe invocation.
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?
Schema description coverage is 0%, so the description must compensate, and it does comprehensively. It explains query semantics, date formats and inclusive ranges, _on/_between exclusivity, assignee_me precedence, sort direction defaults, groupable fields, select behavior, limit cap, and offset continuation—far beyond the bare schema names.
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 opens with a specific verb and resource: 'Search work packages by free text, optionally scoped to a project.' It further distinguishes itself from siblings by explicitly routing version-filtering to list_work_packages and by clarifying that the query matches only subject and numeric ID, not other fields.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit when-to-use guidance and names alternatives: 'To filter by version, use list_work_packages(version=..., project=...) instead.' It also explains scoping behavior with and without project, status/assignee/priority filtering semantics, and pagination via next_offset, leaving little to inference.
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:

[![openproject-ce-mcp MCP server](https://glama.ai/mcp/servers/jtauschl/openproject-ce-mcp/badges/card.svg)](https://glama.ai/mcp/servers/jtauschl/openproject-ce-mcp)

Score Badge

Copy to your README.md:

[![openproject-ce-mcp MCP server](https://glama.ai/mcp/servers/jtauschl/openproject-ce-mcp/badges/score.svg)](https://glama.ai/mcp/servers/jtauschl/openproject-ce-mcp)

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/jtauschl/openproject-ce-mcp'

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