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

No annotations are provided, so the description carries the full burden, yet it discloses nothing about permissions, idempotency (does re-adding a watcher error or no-op?), whether the target user must exist, or what side effects (notifications) occur. Only the bare implication of a state-changing operation is conveyed.

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 front-loaded and free of waste, but it is under-specified rather than truly concise — it omits information an agent needs, so brevity here is a deficit, not an asset.

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?

An output schema exists so return values need not be explained, but for a mutation tool with no annotations and 0% parameter coverage the description is far too thin to support correct invocation.

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

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

Schema description coverage is 0% for two required parameters (issue_id, user_id), and the description mentions neither by name nor clarifies their semantics or format. It does not 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?

The description states a verb ('Add') and resource ('watcher') applied to an issue, so the surface purpose is decipherable. However, it largely restates the tool name add_watcher and adds only the object noun, with no differentiation from siblings such as remove_watcher or update_issue.

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 (e.g., remove_watcher for the inverse, or who may add a watcher). Usage must be fully inferred from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about permissions required, whether archiving is reversible (unarchive_project exists as a sibling), or what happens to the project's issues/time entries. 'Archive' only vaguely implies a mutation.

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

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

One short, front-loaded sentence with no wasted words, which is good. But the brevity reflects under-specification rather than economical communication.

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?

An output schema exists, so return values need not be described. Still, for an unannotated mutation tool with a sibling that reverses it, the definition omits reversibility, permission, and side-effect context an agent needs to call it safely.

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% and the description adds no meaning for project_id — no format, source, or lookup guidance. The single parameter is only faintly self-explanatory from its name.

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 and resource ('Archive a project'), so the agent knows the operation immediately. However, it does not distinguish this from siblings like unarchive_project or delete_project, which are the main confusable alternatives.

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 archive versus delete or unarchive, and no prerequisites or preconditions mentioned. The agent must infer the correct tool solely from the name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure and delivers almost nothing: it does not say which fields are required (project_id, subject), that watchers may be notified, whether defaults apply to omitted fields, or what the response returns. It only implies a write operation and project scoping.

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, front-loaded sentence with no filler, but its brevity reflects under-specification rather than disciplined economy. It is appropriately sized only in the sense that it wastes no words.

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 15-parameter creation tool with no annotations, near-zero schema coverage and no textual help, the description is far too thin. Even with an output schema present, an agent needs required-field, defaults and enum/ID semantics that are entirely absent.

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?

Of 15 parameters, only done_ratio carries a schema description (7% coverage), and the description adds no explanation of any parameter. Critical fields like tracker_id, status_id, priority_id, custom_fields and watcher_user_ids are undocumented in both places, so the agent has no way to know what values are valid.

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 (Create) and resource (issue) plus its scope (in a project), which is clearer than a bare name restatement. However it does nothing to distinguish itself from siblings like update_issue or create_project, relying on the name alone for differentiation.

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 update_issue or create_project, no mention of prerequisites, and no exclusions. An agent gets only the implied 'use this to make a new issue and not to modify one'.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it discloses nothing beyond the bare write intent. Nothing is said about permission requirements, uniqueness/conflict behavior for the identifier, side effects, or whether the new project is immediately visible.

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 short sentence is front-loaded and free of padding, but this is under-specification rather than genuine conciseness — it fails to earn its place by conveying no information beyond the title.

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 mutating tool with no annotations and 0% schema description coverage, the description is completely inadequate. The presence of an output schema excuses explaining return values, but every input-side gap remains unaddressed.

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% across 13 parameters, and the description adds zero meaning for any of them. An agent gets no guidance on name vs identifier, parent_id, tracker_ids, enabled_module_names, or the many other optional fields.

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 'Create a new project' merely restates the tool name and title verbatim, providing no elaboration on scope, resulting artifact, or relationship to siblings like create_issue or list_projects. It is a tautology rather than a distinct statement of purpose.

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 create a project versus using update_project, archive_project, or listing existing ones via list_projects. No prerequisites, no mention that identifier must be unique, and no exclusions are given.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose irreversibility via 'permanently', which is genuinely useful, but says nothing about required permissions, cascading side effects (watchers, comments, time entries), or confirmability of a destructive operation.

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

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

One short sentence, front-loaded with verb and resource, with no wasted words. Its brevity borders on under-specification rather than tight conciseness, but structurally it is clean.

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?

An output schema exists so return values need not be explained, but for a permanent, annotation-free destructive tool the definition omits permissions, side effects, and any warning about irreversibility, leaving the agent insufficiently briefed before an irreversible call.

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% on the single issue_id parameter, and the description adds no parameter meaning at all. The parameter is largely self-explanatory by name, but the description does nothing 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 a specific verb (delete) and resource (issue), and 'permanently' clarifies the operation's nature. It is distinguishable from siblings like update_issue or create_issue, but does not differentiate against any soft alternative (e.g. archiving), and there is no archive_issue sibling to name.

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?

No explicit when-to-use guidance, no prerequisites, and no statement about when deletion is appropriate versus updating or leaving the issue alone. The word 'permanently' is a faint caution but is not framed as usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Permanently' usefully discloses irreversibility, but it says nothing about required permissions/ownership, whether related issues, time entries or watchers are cascaded or orphaned, or whether failures are recoverable — all critical for an irreversible mutation.

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

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

One short sentence with the destructive qualifier front-loaded and no filler. It is efficiently sized, though the terseness is under-specification rather than optimal conciseness.

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?

An output schema exists so return values needn't be explained, and the single flat parameter limits schema complexity. But for an irreversible delete with no annotations, missing cascade/permission effects and no distinction from archive_project leaves the definition under-complete for correct invocation.

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

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

Schema description coverage is 0% for the single required project_id, so all semantic burden falls on the description, which says nothing about the parameter (format, whether it is the ID versus key, or where to obtain it). The name is fairly self-evident, but no compensating detail is offered.

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?

Clear verb+resource ('Delete a project') with the added adverb 'permanently' signaling finality, so the agent knows it is destructive rather than reversible. However, it makes no attempt to distinguish itself from siblings like archive_project/unarchive_project, which is the most likely source of misfire in this tool set.

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?

No guidance on when to use this versus archive_project or update_project. Since 'permanently' is stated, the natural implicit contrast is archiving, but the description never names the alternative or the condition that selects it.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does almost nothing with it. It never states that this is a read-only operation, whether permissions or visibility scoping apply, or what 'detailed information' encompasses.

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 that is front-loaded with the verb and resource. It is efficient, but its brevity 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?

An output schema exists, so return values need not be described, but the undocumented 'include' parameter and the total absence of usage or behavioral context leave the agent without what it needs to call this confidently. For a lookup tool with a mystery parameter, more was required.

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%. The required issue_id is self-explanatory from its name, but the optional 'include' parameter (string or null, no description, no enum) is completely opaque — the description must explain its accepted values but says nothing.

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

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

The description states a clear verb+resource pair ('Get... a specific issue') and signals that it returns detail for a single record. It does not, however, distinguish itself from the sibling list_issues or explain how 'detailed' differs from what that tool 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?

There is no guidance on when to use this versus list_issues or search, nor any prerequisite or exclusion information. The only usage signal is the implied 'single issue vs. collection' convention.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing beyond the implied read semantics. It does not mention permission requirements, whether archived projects are retrievable, or behavior when the project 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.

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

It is a single efficient sentence with no filler and is front-loaded, but it is under-specified rather than truly concise — the brevity comes at the cost of missing information rather than from tight 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?

An output schema exists, so return values need not be spelled out, but with zero annotations and zero parameter documentation the description leaves the 'include' parameter and error/permission behavior entirely unexplained for a tool an agent must call with a valid identifier.

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%, and the description adds no meaning for either parameter. In particular the 'include' parameter is completely unexplained — its accepted values and effect are documented nowhere, which is a real gap for a caller.

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 a clear verb ('Get') and resource ('project') scoped to a single, specific entity, which separates it conceptually from list_projects. However, it offers no explicit differentiation from the many sibling project tools (update_project, archive_project, list_projects) and 'detailed information' is vague about what is actually returned.

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 statement of when to use this tool versus alternatives, nor any prerequisites (e.g., how to obtain a project_id, or that list_projects can be used to discover one). The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It never states that this is a read-only operation, what happens if the ID does not exist or is inaccessible, or whether permissions are required, all of which matter for a single-record fetch.

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 well-formed sentence with no filler and the resource stated up front. It is efficient, though so terse that it leaves little room for the routing or behavioral context an agent would want.

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

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

The tool is simple (one required param, no nesting) and an output schema exists, so return values need not be explained. However, with no annotations and no usage guidance, the definition is only minimally complete for distinguishing it from list_time_entries.

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

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

Schema description coverage is 100% and the sole parameter is fully documented in the schema, so the baseline of 3 applies. The description adds nothing about the ID's format or source beyond what the schema already says.

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 a specific verb ('Get') and resource ('time entry') restricted to a single record, so the operation is unambiguous. It does not, however, differentiate itself from the sibling list_time_entries beyond the word 'specific', leaving the single-vs-list distinction to be inferred from the name.

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

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

There is no explicit guidance on when to use this tool versus list_time_entries, nor any mention of prerequisites such as needing a valid time_entry_id. The phrase 'a specific time entry' hints at single-record retrieval, but no alternative is named or ruled out.

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

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

No annotations are provided, so the description carries the full behavioral burden. It mentions pagination but does not disclose default page size behavior, that fetch_all overrides offset, permission/auth requirements, or anything about the read-only nature beyond what "List" implies. For a 10-parameter query tool this is thin.

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 wasted words. It is efficient, though the sparseness reads more as under-specification than deliberate compression.

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?

Ten parameters, no annotations, and an output schema present. Given that complexity, the description should at least gesture at the filter dimensions available and the fetch_all/limit/offset interaction; it says only "optional filters and pagination," which is not enough context for correct invocation.

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

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

Schema description coverage is 100%, so every parameter already carries its own documentation, including the sort syntax, limit cap, offset, and fetch_all semantics. The description adds nothing beyond a generic reference to "filters and pagination," so the baseline 3 is appropriate.

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

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

The description names a specific verb and resource ("List issues") and notes scope ("optional filters and pagination"), so an agent knows this is a read/query operation. However, it offers no differentiation from siblings like search or get_issue, leaving the agent to infer the boundary from the name alone.

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?

"With optional filters" implies a filtered-listing use case, but there is no explicit when-to-use, no when-not-to-use, and no pointer to alternatives such as search or get_issue for single-issue retrieval. The agent gets no routing guidance.

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

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

No annotations exist, so the description carries the full behavioral burden. It does disclose two traits beyond the schema: results are scoped to accessible projects and the response is paginated. It omits permission requirements, ordering, and page-size limits, so disclosure is partial.

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 waste. It is efficient, though its brevity comes at the cost of needed detail rather than being tightly informative.

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?

An output schema exists, so return values need not be described. But with zero annotations, zero schema description coverage, and an undocumented 'include' parameter, the definition leaves real gaps for a listing tool that supports field expansion.

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% for all three parameters. The description's mention of pagination loosely gestures at limit/offset but adds no format, defaults, or bounds, and the 'include' parameter is entirely unexplained in both schema and description. It 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 a specific verb and resource ('List all accessible projects') and signals scope via 'accessible'. However, it does not differentiate itself from siblings such as get_project or list_issues, so an agent must infer that this is the multi-item lister rather than the single-project fetcher.

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 alternatives (get_project for a single project, search for filtered lookups), and no prerequisites. 'Accessible' hints at a permission-scoped listing but that is inference, not guidance.

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

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

With no annotations, the description carries the full burden, and it only discloses that pagination exists and filters are optional. It never states the read-only nature explicitly, nor auth requirements, defaults, or rate limits. An output schema exists, so return-value detail is fairly excused, but the behavioral picture remains thin.

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 padding or repetition. The trailing "with optional filters and pagination" is slightly generic but still earns its place by naming the two operative dimensions.

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 an 8-parameter list tool with full schema coverage and an output schema, the essentials for invocation are present. However, the fetch_all pagination behavior and the read-only nature are never surfaced at the description level, leaving the agent to reconstruct usage from structured fields alone.

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% across all 8 parameters, so limit, offset, fetch_all, and every filter are already documented in the schema. The description adds no syntax, format, or interaction detail beyond that, which is the expected baseline when the schema does the heavy lifting.

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 and resource ("List time entries") and notes the two axes it operates on, filters and pagination. It implicitly distinguishes itself from the singular sibling get_time_entry, but never names or contrasts with it explicitly, so differentiation is left 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, no prerequisites, and no mention of the pagination-vs-fetch_all tradeoff that the schema flags for reports/aggregations. "Optional filters and pagination" describes what the tool does, not when an agent should choose it over get_time_entry or search.

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

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

With no annotations, the description carries the full behavioral burden, yet it discloses nothing beyond the operation itself: no idempotency (what if the user is not a watcher), no permission requirements (can you remove someone else's watch?), no reversibility, and no side effects such as notification changes.

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 tight sentence with no padding, and the operation and target are front-loaded. It is efficient, though arguably minimal to a fault.

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?

An output schema exists so return values need not be explained, but for a mutation tool with zero annotation coverage and 0% parameter documentation, the description omits auth requirements, idempotency behavior, and error conditions an agent needs to call it correctly.

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

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

Schema description coverage is 0% and neither parameter has an enum or description, so the schema provides no meaning for issue_id or user_id. The description does not compensate, leaving it unclear whether user_id is a user identifier or a watcher-record identifier.

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

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

The description states a specific verb and resource ('Remove a watcher from an issue'), which lets an agent distinguish it from the add_watcher sibling by antonym. It does not, however, explicitly name that sibling or clarify scope (e.g., only the caller's own watch vs. any watcher).

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 preconditions, and no mention of alternatives such as add_watcher or the issue update tools that might also affect watchers. Usage must be inferred entirely from the verb.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: it does not mention that results are paginated (limit/offset exist), how the scope parameter defaults, whether the search is read-only, or what determines which resource types are returned. The single sentence adds zero 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.

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

It is short and front-loaded, so it is not bloated, but the brevity here is under-specification rather than conciseness. A single six-word sentence cannot earn its place as the only documentation for a 14-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?

For a 14-parameter search tool with zero annotation coverage and zero schema descriptions, the description is wholly inadequate. Although an output schema exists (so return structure need not be explained), nothing about filtering, scoping, or pagination is covered, leaving the agent unable to configure the search correctly.

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

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

Schema description coverage is 0% across 14 parameters, and the description compensates for none of them. Critical semantics such as the meaning of scope, the boolean resource-type toggles, all_words, titles_only, open_issues, limit, and offset are entirely undocumented anywhere.

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 ('Search') and a broad resource domain ('Redmine resources'), so an agent knows the general operation. However, it never says which resource types are searchable (issues, news, wiki_pages, documents, changesets, messages), all of which are exposed as parameters, and offers no differentiation from the sibling list/get tools beyond the verb.

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 statement of prerequisites or scope defaults, and no mention of when a sibling such as list_issues would be preferable. An agent must infer everything about invocation context from the name alone.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it discloses nothing about permissions required, reversibility, side effects, or the resulting project state. Only the implied inverse of 'archive' hints at the effect.

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, but it is under-specified rather than genuinely concise. There is no wasted text, but there is also almost no content.

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

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

Although an output schema exists (so return values need not be explained), a mutation tool with no annotations and an undocumented required parameter leaves the agent without permission, reversibility, or state-transition information.

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

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

There is one parameter (project_id) with 0% schema description coverage, so the description must compensate and does not; it says nothing about what project_id accepts or its format. The 0-param baseline of 4 does not apply since a required undocumented parameter exists.

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 'Unarchive a project' merely restates the tool name and title, adding no differentiating detail beyond the verb+resource already present in unarchive_project. It does not clarify scope (e.g., what state the project returns to) or distinguish itself from neighbors like archive_project.

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?

No guidance on when to use this tool versus alternatives such as archive_project or update_project. The existence of a sibling archive_project makes explicit when/when-not guidance valuable, and none is offered.

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

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

With no annotations provided, the description carries the full burden and delivers nothing. It does not state whether omitted fields are preserved (partial update) or cleared, whether the caller needs permissions, whether changes are reversible, or that issue_id must reference a pre-existing issue. For a 19-parameter mutation tool this is a serious gap.

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 wasted words and is trivially front-loaded, so it is not bloated. However, its brevity reflects under-specification rather than discipline, which caps the score at adequate.

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?

An output schema exists so return values need not be explained, but for a 19-parameter mutation tool with no annotations and 5% schema coverage the description is wholly inadequate. It omits partial-update semantics, ID reference rules, and any field-level context.

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 5% across 19 parameters, and the description adds zero parameter meaning. Field names like status_id, tracker_id, category_id, and fixed_version_id imply lookup IDs with no hint of valid values, and custom_fields has no shape guidance anywhere.

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 restates the tool name and title almost verbatim ('Update an existing issue' for update_issue). It conveys no scope, no indication of what fields can be updated, and does not distinguish it from siblings such as create_issue or delete_issue beyond the obvious verb.

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?

No when-to-use guidance, no prerequisites, and no mention of alternatives. The agent is left to infer that update_issue applies to existing issues and create_issue to new ones, which is trivially guessable but 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?

With no annotations and almost no description content, the tool's behavioral traits are completely undisclosed. For a mutation with 13 optional parameters, an agent cannot tell whether updates are partial or full, what permissions are required, whether changes are reversible, or what side effects occur.

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 technically concise, but it is under-specified relative to the tool's complexity. It fails to front-load any useful detail for a 13-parameter mutation, making the brevity a liability rather than a strength.

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

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

Given 13 parameters, no annotations, and only one required parameter, the description is drastically incomplete. While an output schema exists, that does not excuse the absence of any information about the update behavior, parameter meanings, or usage constraints.

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%, and the description adds no meaning for any of the 13 parameters. With such low coverage, the description must compensate, but it offers nothing beyond the tool's name.

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

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

The description states a specific verb ('Update') and resource ('existing project'), making the tool's basic function clear. However, it does not distinguish this tool from siblings like create_project, delete_project, or archive_project beyond the verb itself.

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 archive_project or update_issue, nor any mention of prerequisites or context. The description provides only the bare action.

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