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

Annotations already declare read-only, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds a useful behavioral detail that content is limited to text files, but does not mention truncation via max_chars or other retrieval limits.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for a simple retrieval tool.

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

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

For a tool with an undocumented max_chars parameter and no output schema, the description should explain truncation or content-size behavior. It omits this entirely, leaving the agent without enough context to call the tool correctly when requesting large text content.

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

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

Schema description coverage is only 33%, so the description should compensate, but it does not explain max_chars at all or clarify attachment_id. It only loosely maps to include_content by saying content is optional for text files, which the schema already states.

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

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

The description states a specific resource and scope: it returns attachment metadata and, for text files, optionally the content. That is enough for an agent to know what the tool does, but it does not differentiate from any sibling tool because no sibling in the list covers attachments directly.

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

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

The description explains what is returned but not when to call this tool instead of alternatives, nor any prerequisites or conditions for using include_content. The only guidance is implicit: content is available for text files only.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the payload includes memberships (useful since no output schema exists) and hints that identity comes from server configuration, but says nothing about pagination, permissions required, or response shape.

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

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

A single compact sentence with no filler, and the key fact (which user) is front-loaded. It is a fragment rather than a full statement, but nothing is wasted.

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

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

For a zero-parameter read whose annotations fully carry the safety profile, the description states what is returned (the acting user plus memberships) and where the identity comes from. Nothing an agent needs to call it correctly is missing.

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

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

The tool takes zero parameters, so there is no per-parameter semantics to explain; the baseline for a parameterless tool applies and the description does not need to compensate for anything.

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

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

The description names the exact resource returned — the Redmine user the server authenticates as — and its scope ('with its memberships'). That distinguishes it from sibling user-oriented tools like list_project_members, though it is a noun phrase rather than an explicit verb+resource statement.

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

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

Usage is implied by the concept ('the user this server acts as'), so an agent can infer this is the identity lookup, but there is no explicit when-to-use, no exclusions, and no reference to an alternative sibling.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description does add useful content-level context (that journals, attachments, relations and sub-issues are returned together), but says nothing about permissions, error behavior when the ID is absent, or cost/pagination.

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

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

It is a single short sentence with no filler, which is efficient. However, the terseness is achieved by dropping the verb and any usage context, so this is under-specification rather than disciplined concision.

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

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

For a 2-parameter read tool with annotations but no output schema, the description should at minimum state the operation and how it relates to search_issues and the include parameter. It conveys only the shape of the returned payload, leaving an agent without the verb, usage context, or a full picture of the include options.

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

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

Schema description coverage is 50%: the include parameter is documented in the schema ('Defaults to journals, attachments, relations, children') while issue_id is not, though it is self-evident. The description roughly mirrors the default include set but uses 'subtasks' where the schema enum says 'children', and it omits the other selectable values (watchers, changesets, allowed_statuses), so it adds little beyond the schema.

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

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

The description names the resource and enumerates what accompanies it (history, attachments, relations, subtasks), so an agent can infer it fetches one issue. But it is a bare noun phrase with no verb ('retrieve', 'fetch'), and it never contrasts itself with the obvious sibling search_issues or the list-style tools, so differentiation is left entirely to inference.

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

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

There is no when-to-use guidance at all: no statement that this is the single-issue lookup versus search_issues for filtered bulk retrieval, and no prerequisites. The only usage signal is the required issue_id, which comes from the schema, not the description.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and open-world, so the safety profile is covered. The description usefully discloses the returned payload composition (trackers, categories, modules, time entry activities), which is real context beyond annotations, but it says nothing about failure behavior for an unknown project or permission requirements.

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

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

A single short sentence with no filler; each enumerated sub-resource earns its place. The only structural weakness is that it is a noun fragment rather than a verb-led statement, so it reads as a return-value caption rather than a tool purpose.

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

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

With no output schema, the description is the only source of return-shape information, and it does cover the payload contents. For an otherwise simple, fully-annotated single-parameter read tool that is close to adequate, but the absence of any action framing or error behavior leaves a gap.

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

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

Schema description coverage is 100% and the single 'project' parameter is fully documented in the schema with an example and the id-or-slug alternative. The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

The description is a noun fragment ('A project with its trackers, issue categories, enabled modules and time entry activities') that never states a verb, so the retrieval action must be inferred from the name get_project. It does add specificity by enumerating the related sub-entities included in the payload, which helps distinguish it from list_projects, but the core purpose is only implied.

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

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

There is no when-to-use guidance, no mention of the sibling list_projects, and no note that this requires a specific project identifier. The agent gets no help deciding between fetching one project versus listing all projects.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered by structured data. The description adds almost nothing beyond that: it does not say what happens when the page or version is missing, whether auth or project access is required, or how large the text payload can be.

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

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

A single short fragment, so there is no padding, but this is under-specification rather than true conciseness. It is front-loaded but does not carry the information an agent needs for a three-parameter tool.

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

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

With no output schema, three parameters, and low schema description coverage, the description should carry more of the load. It omits error behavior, version discovery, and any distinction from the wiki listing sibling, leaving clear gaps for a retrieval tool.

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

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

Schema coverage is only 33% (only 'project' is documented), so the description must compensate. It clarifies that 'version' selects an older revision rather than the current one, which adds real meaning over the bare integer schema, but 'title' remains undocumented and the version semantics stay vague (how to discover valid versions).

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

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

The description is a noun fragment ('A wiki page with its text, optionally an older version') rather than a verb+resource statement, but it does convey the resource retrieved and the key content (page text plus version selection). It gives no differentiation from the sibling list_wiki_pages, so an agent must infer that this fetches a single page.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no reference to alternatives such as list_wiki_pages for browsing versus this tool for fetching one page. The optional version is hinted at but the condition for choosing it is never stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds nothing behavioral beyond that – no note on pagination behavior, permissions required, or whether roles are returned inline or as identifiers.

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

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

At six words it is undeniably concise and front-loaded with the resource. But it is a bare noun phrase rather than a complete statement of purpose, so brevity here reflects under-specification rather than disciplined editing.

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

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

For a simple read-only list endpoint with complete parameter documentation and full safety annotations, the minimum is met. However, with no output schema and no description of the return shape, the agent cannot know what a member record contains beyond the vague hint about roles.

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

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

Schema description coverage is 100%, so project, limit, and offset are all documented in the schema itself, including the next_offset pagination hint. The description's mention of "roles" hints at output content but adds no meaning to the parameters, so the baseline 3 applies.

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

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

The fragment "Members of a project with their roles" conveys the resource (project members) and adds the roles detail, which goes slightly beyond the tool name. However, it lacks an explicit verb and does not distinguish this tool from any sibling (e.g. list_projects or get_project), leaving the agent to infer the listing action.

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

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

There is no guidance on when to use this tool versus alternatives such as list_projects, get_project, or get_current_user. No prerequisites, no exclusions, no context about when a project-member listing is the right call.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds a useful behavioral constraint—only projects visible to the server's Redmine user are returned—but does not describe pagination or return format.

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

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

The description is a single short fragment with no wasted words, and the scope constraint is front-loaded. It could be slightly more informative or grammatically complete without becoming bloated, but it is efficient.

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

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

For a simple paginated read-only list tool with rich schema and annotations, the description states what projects are returned but omits an explicit listing verb and any return-shape context. No output schema exists, so return values are left implicit, creating a minor gap even though the tool name helps.

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

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

Schema coverage is 100%, and both limit and offset are documented in the schema. The description adds no additional meaning about how these parameters work, so the baseline of 3 applies.

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

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

The name supplies the verb 'list' and the description identifies the resource 'Projects' with a scope constraint ('visible to the server's Redmine user'). It does not explicitly differentiate from siblings like get_project or list_project_members, but the core purpose is clear without opening the schema.

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

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

The description provides no when-to-use guidance, no alternatives, and no exclusions. It only states the scope of projects returned, leaving the agent to infer when this tool is preferable to get_project or other list tools.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the safety profile is covered. The description adds genuinely new behavioral context beyond the annotations by flagging that custom_fields and groups are '(admin only)', i.e. an authorization requirement for specific kinds.

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

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

Two compact lines with no filler, framed by the purpose clause before the enumeration. Efficient and front-loaded, though the parenthetical admin notes could be tidied into the list more cleanly.

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

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

For a single-enum-parameter, read-only reference lookup with no output schema, the description covers what data is available and the admin caveat on two kinds. Annotations handle safety, so nothing critical is missing, though noting the return shape (list of id/name pairs) would round it out.

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

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

Schema description coverage is 0%, so the description must carry the burden, and it does enumerate the kinds the single 'kind' parameter accepts (statuses, trackers, priorities, activities, categories, custom fields, queries, roles, groups). It also adds per-value qualifiers ('admin only') that the bare enum values do not convey.

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

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

The description identifies the tool's content precisely (IDs and names of reference data for filters/changes) and enumerates the nine kinds, distinguishing it from activity siblings like list_projects or search_issues. It lacks an explicit leading verb ('List'), so it reads more as a content inventory than an action statement, but an agent can still tell what it returns.

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

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

The phrase 'needed for filters and changes' implies the use case — fetching IDs/names to feed other operations — but there is no explicit when-to-use versus alternatives and no exclusions. Usage is inferred rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered by structured data. However, the description adds nothing beyond that: no pagination behavior, no note that results are filterable by user/project/date, and no indication of ordering or empty-result behavior.

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

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

Three words is not conciseness but under-specification. There is no front-loaded purpose statement to trim, so brevity here signals missing information rather than efficiency.

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

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

For a 7-parameter filtered list tool with no output schema and no annotations describing return shape, the description is completely inadequate. An agent has no basis for choosing filters, paging strategy, or interpreting results.

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

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

Schema description coverage is 71%, below the 80% baseline where the schema fully carries the burden. The description contributes zero parameter meaning; it does not clarify the interaction of from_date/to_date, the user="me" convention, or how offset/limit are used for paging.

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

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

"Spent time entries." is a noun fragment that restates the resource already implied by the tool name and adds no verb or scope. It does not distinguish this list tool from siblings like list_projects or search_issues; there is no statement of what is being listed or in what context.

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

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

The description provides no when-to-use guidance, no prerequisites, and does not mention any alternative among the available list/search siblings. Nothing tells the agent when this tool is the right choice.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered by structured data. The description adds the useful scoping note that shared versions are included, which is real context beyond the annotations. It does not mention pagination or return shape, so it adds only moderate value.

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

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

The single sentence is short and front-loaded with no wasted words. However, it is a bare noun phrase fragment with no verb, and the brevity comes at the cost of specification rather than being genuinely efficient prose.

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

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

For a read-only paginated list tool, the annotations cover safety and the schema covers parameters, so the minimal description is close to sufficient. It still leaves the scope of returned version data and the pagination behavior unmentioned, which an agent calling this tool would benefit from knowing.

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

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

Schema description coverage is 100%, so limit, offset, and project are already fully documented in the schema, including the next_offset pagination hint. The description adds no additional parameter meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description names the resource (versions/milestones/releases of a project) and clarifies they include shared ones, so the agent knows what is returned. However, there is no explicit verb and no differentiation from sibling listing tools such as list_projects or list_wiki_pages; the agent has to infer 'list' from the tool name. Adequate but vague about scope compared to a fully formed verb+resource statement.

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

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

The description gives no when-to-use guidance, no prerequisites, and names no alternative or sibling. The phrase 'of a project' only hints that a project is required, which the schema already enforces. No exclusions or routing advice is present.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so safety is fully covered elsewhere. The description adds essentially nothing beyond them — no note on result ordering, pagination behaviour, or whether the response is truncated at the limit.

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

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

A single short sentence with no filler, correctly front-loaded. It is efficient, though the brevity edges toward under-specification rather than crispness.

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

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

For a simple three-parameter read tool with full schema coverage and annotations covering safety, the description is only just adequate. It omits anything about pagination workflow and the relationship to get_wiki_page, which are the main things an agent would need context for.

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

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

Schema description coverage is 100%, so limit, offset and project are all already documented (including the useful "use next_offset of the previous page" hint on offset). The description contributes no additional parameter meaning, so the baseline 3 applies.

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

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

The phrase "Index of the wiki pages of a project" identifies the resource (wiki pages) and its scope (a single project), but it is a bare noun phrase with no verb, so the agent must infer that this is a listing/read operation from the tool name alone. It also does nothing to separate it from the sibling get_wiki_page, which retrieves a single page.

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

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

There is no when-to-use guidance at all: no mention of when to prefer this over get_wiki_page, search, or search_issues, and no note about paginating through results. The agent is left to infer usage entirely from the name and the sibling list.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the parenthetical '(read-only)' is redundant restatement. The description adds nothing about error behavior for unknown resources, required auth, or how params interact with the target resource.

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

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

A single terse sentence with no filler and the key qualifier '(read-only)' front-loaded. It is appropriately sized, though the fragment style leaves no room for the routing context an agent needs.

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

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

No output schema exists, but annotations carry the safety profile and the schema fully documents the parameters. The remaining gap is the failure to explain how this generic tool relates to the many resource-specific getters, which is exactly what an agent must decide before invoking it.

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

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

Schema description coverage is 100%, with each of the three parameters documented in the schema itself (including examples for params, resource, resource_id). The description adds no syntax or semantics beyond that, so the baseline 3 applies.

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

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

The description states a clear verb and scope: fetching a single Redmine resource by id. The word 'single' implicitly contrasts with redmine_list, so an agent can distinguish the retrieval shape from the listing sibling.

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

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

There is no guidance on when to use this generic fetch versus the specialized siblings get_issue, get_project, get_wiki_page, or get_attachment. The agent is left to infer that redmine_get is a fallback for resource types without a dedicated tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so safety and side-effect behavior are covered. The description adds one genuinely extra behavior: an unrecognized resource name returns the available resource list, which is useful for recovery from bad input, but it says nothing about pagination limits or error behavior beyond that.

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

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

Two short sentences, no filler, with the core capability stated first and the fallback behavior second. Appropriately sized for a thin generic wrapper, though the phrasing 'Any Redmine resource list' is slightly loose.

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

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

With 4 parameters, 100% schema coverage and no output schema, the description covers the basics, but the most important missing piece for a generic tool surrounded by specific siblings is routing guidance, which is absent. The unknown-name fallback is the one real added behavior.

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

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

Schema description coverage is 100%, so the schema already explains limit, offset, filters, and resource (including snake_case examples). The description adds only the coarse 'filtered or all' distinction, which the filters description already states, so this sits at the schema-driven baseline.

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

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

It conveys a generic verb+resource ('Any Redmine resource list, filtered or all') and notes the read-only nature, but 'Any ... list' is vague about scope and gives no differentiation from the specific sibling listers (list_projects, search_issues, list_time_entries, list_versions, list_project_members, list_wiki_pages). An agent cannot tell from the description alone whether to prefer this catch-all or a dedicated sibling.

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

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

There is no when-to-use guidance and no mention of alternatives. The only implicit usage signal is 'Unknown names return the list of resources,' which suggests a discovery path but never says when this generic tool should be chosen over the specific list_* siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds the cross-resource scope of the search, which is useful context, but says nothing about pagination behavior despite offset/limit parameters existing.

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

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

A single front-loaded sentence with no filler, appropriately sized for the scope statement. It is efficient, though it stops short of the structure (e.g., usage or pagination notes) that a 7-parameter tool could support.

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

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

With 7 parameters, 57% schema coverage, no output schema and no title, the description leaves pagination, type filtering, and project scoping entirely to the schema. For a broad search tool it is under-specified about how to constrain and page results.

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

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

Schema description coverage is only 57%, and the description adds no meaning beyond it — it does not explain the query parameter, the types filter, project scoping, or how offset/limit paginate. The content-type list loosely maps to the 'types' parameter but is not framed as parameter guidance.

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

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

States a specific verb ('full text search') and resource ('Redmine') and enumerates the six content types it covers. It is clearer than the bare name 'search', but it does not distinguish itself from the sibling search_issues, which overlaps with the 'issues' type listed here.

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

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

The description gives no when-to-use guidance, no prerequisites, and never mentions alternatives such as search_issues for issue-only lookups. An agent must infer from the type list that this is the broader search, which is only implicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavior beyond the structured data: results are truncated (long descriptions shortened), which tells the agent results are lossy and may require a follow-up call. It does not mention pagination behavior, though the schema covers offset/limit.

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

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

A single tightly-packed sentence with zero filler, front-loading the core behavior and appending the routing hint where it is most useful.

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

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

For a 13-parameter read-only search with no output schema, the description covers the key behavioral caveat (truncated results) but leaves filter composition, sorting semantics, and result shape largely unexplained. It is minimally adequate rather than complete.

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

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

With 13 parameters at 69% schema coverage, the description only alludes to 'filters' generically and adds no syntax, defaults, or meaning beyond the schema. Several parameters (parent_id, tracker_id, fixed_version_id) carry no description in either place, so the description fails to compensate for the coverage gap.

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

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

States the resource (issues) and the matching behavior (filters), and explicitly contrasts itself with get_issue, so an agent can distinguish it from the full-retrieval sibling. It stops short of a clean verb such as 'search/list', and it never distinguishes itself from the generic 'search' sibling in the toolset.

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

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

The parenthetical does give one routing rule: use get_issue when the full issue description is needed. However there is no guidance on when to use this over the sibling 'search' tool, nor on how the filter parameters should be combined, so usage is only partially implied.

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