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

No annotations are provided, so the description carries the full burden. It only says 'Get' which implies read-only, but does not disclose any behavioral traits such as permission requirements, rate limits, or side effects. The listing of return fields is more about output content than behavioral transparency.

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

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

The description is two sentences, front-loaded with the action and resource, and every word adds value. It is efficient and clear without redundancy.

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

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

For a simple get tool, the description covers purpose, key return fields, and usage context. It lacks an output schema but lists enough about the return content. It does not mention error scenarios or permission requirements, but these are not critical for selection and 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?

Input schema has 100% coverage with descriptions for all three params (org, project, event_id), so baseline is 3. The description does not add extra meaning beyond the schema, just references 'by its ID' which is already covered.

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

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

The description clearly states the action ('Get') and specific resource ('full details of a specific event by its ID'), listing included data (exception values, stack trace, etc.). It distinguishes itself from siblings like list_issue_events (which lists events) and get_issue (which gets an issue, not an event) by emphasizing a specific event's full details.

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 explicitly says 'Use this to debug a specific occurrence,' providing clear when-to-use context. However, it does not mention when not to use it or name alternatives, though siblings are evident from context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It communicates the read-only nature by saying 'Get full details' and lists the fields returned, which is useful. However, it does not disclose potential error conditions, access requirements, or any side effects, which are not substantial for a simple getter but still represent a 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?

The description is a single, well-structured sentence that front-loads the purpose and efficiently lists the returned fields. Every phrase adds value, and there is no redundant or vague wording.

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

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

For a simple one-parameter getter with no output schema, the description is complete: it states the action, the resource, the parameter source, and the exact fields returned. It sufficiently distinguishes this tool from its sibling tools and covers the essential context an agent needs.

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

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

The schema description coverage is 100% and already explains the parameter (numeric ID, example, and source from list_issues). The description merely repeats 'numeric ID' without adding new information. Thus, the baseline of 3 is appropriate, as 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?

The description clearly states the verb 'Get' and the resource 'specific issue', and specifies it's by numeric ID. It also enumerates the returned fields (title, culprit, metadata, tags, etc.), distinguishing it from sibling tools like list_issues (which lists) and get_event (which gets events).

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 clear context for when to use the tool: to retrieve full details of a single issue. It also gives a hint that issue IDs come from list_issues, which is a practical usage pointer. However, it does not explicitly mention when not to use it or alternative tools for similar purposes, so it falls short of a 5.

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 must carry the full burden. 'Get' implies a read-only operation, and the description explains what is returned (grouping hashes). However, it does not explicitly state that the operation is safe or describe any potential side effects, though the read-only nature seems implicit.

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

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

The description is two sentences, front-loaded with the primary action, and contains no filler. Every clause provides useful information: what the hashes are, and why they are 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 simple single-parameter read operation with no output schema, the description is sufficient. It explains the return value and use cases. It could mention whether the result is an array of hashes, but the phrase 'grouping hashes' and the deduplication context imply multiple hashes.

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% for the single parameter 'issue_id', which is documented as a numeric ID. The description adds minimal extra meaning—'specific issue' is redundant with the parameter name. Baseline of 3 applies since the schema already fully describes the parameter.

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

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

The description clearly states the tool retrieves grouping hashes (fingerprints) for a specific issue, using a specific verb ('get') and resource ('grouping hashes'). This distinguishes it from sibling tools like get_issue, which fetches full issue details, and list_issues, which lists issues.

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

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

The description indicates when to use the tool: 'to identify why issues are grouped together or to deduplicate across projects.' This provides clear context and use cases, though it does not explicitly mention when not to use it or compare with alternatives.

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 full burden. It explicitly lists the data returned (commit info, last commit, first/last event, deploy count, new issues, associated projects), giving an agent concrete expectations. It does not mention read-only status or error conditions, but for a get operation, this disclosure is reasonably transparent.

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

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

The description is a single sentence that front-loads the action and resource, then compactly lists the returned details. There is no redundancy or filler, making it highly scannable.

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

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

Given the tool's simplicity (2 parameters, no output schema), the description adequately explains what the tool returns by listing the details. It lacks explicit response structure, but this is not critical for a get-by-key tool, and the description covers the essential information for an agent to decide and invoke 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 coverage is 100% with clear descriptions for both parameters (org, version), including guidance to get versions from list_releases. The tool description adds no additional parameter semantics beyond what the schema provides, so 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 uses the specific verb 'Get' with a clear target 'specific release by version' and enumerates the included details (commit info, deploy count, etc.). This makes it unambiguous and distinguishes it from sibling tools like list_releases, which lists releases rather than fetching details for one.

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

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

The description implies the use case: retrieving details for a single known release version. The version parameter hint ('Get these from list_releases') suggests a workflow but is in the schema, not the tool description. The description itself gives clear context for when to use this tool, without exclusions or alternatives.

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. It discloses the return fields (event id, message, platform, dateCreated, tags), which is valuable, but does not mention pagination behavior, ordering, or that it is a read-only operation. The cursor parameter is only documented in the schema, not in the description.

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

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

The description is two sentences, starts with the core action and resource, and includes only necessary details. Every sentence earns its place: the first states the operation, the second lists return fields and a use case.

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 list tool with only two parameters and no output schema, the description is mostly complete: it covers what the tool does, what it returns, and a common use case. It omits mentioning pagination explicitly, though the schema's cursor description fills that gap. Overall, adequate for the tool's complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The schema already explains both parameters (cursor and issue_id). The description only says 'specific issue', which does not add meaning beyond the schema's 'Numeric issue ID'. No additional parameter-level insight is provided.

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

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

The description clearly states the action ('List all events') and the target resource ('for a specific issue'), adding the clarifying phrase 'individual occurrences' to distinguish events from issues. This differentiates the tool from siblings like get_event (which likely fetches a single event) and get_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?

The description gives a concrete use case ('Use to find the most recent occurrence'), providing clear context for when to invoke this tool. However, it does not explicitly mention alternatives or when not to use it, which would make it fully explicit.

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 burden. It discloses return fields and the definition of an issue, but does not explicitly state read-only behavior, pagination behavior, or authentication requirements. Given it is a list operation, the behavior is mostly inferable, but some explicit transparency about side effects or limitations is missing.

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

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

The description is two sentences, front-loaded with the primary action, and every sentence adds value (purpose and output characteristics). It is concise, readable, and avoids fluff.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description provides a solid overview: what it does, what an issue is, and what fields are returned. It lacks explicit mention of pagination defaults or sorting, but these are covered in the schema. The description is complete enough for most usage scenarios.

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

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

Schema description coverage is 100%, so the schema already documents all parameters with descriptions. The description adds no extra parameter-level meaning beyond grouping them as 'optional filters'. It does list return fields, which are not part of parameter semantics. 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 clearly states 'List issues in an organization with optional filters', using a specific verb and resource. It further clarifies what an issue is ('unique error grouped by fingerprint') and lists returned fields, distinguishing it from sibling tools like get_issue and list_issue_events.

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

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

The description gives clear context: this tool lists issues in an org, with optional filters. It doesn't explicitly mention alternatives or exclusions, but the scope is evident from the phrasing. The project parameter references list_projects for IDs, providing some cross-tool 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 provided, the description carries the full burden of behavioral disclosure. It only states the return fields and does not mention pagination behavior (despite a cursor parameter), authentication requirements, rate limits, or the read-only nature of the operation, leaving significant behavioral ambiguity.

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

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

The description is two sentences, front-loads the action, and includes only essential information without redundancy. Every word contributes to understanding the tool's purpose and output.

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 listing tool, the description covers the core functionality and return fields, but it omits pagination details and any required permissions. Given there is no output schema, the return field list helps, but the lack of behavioral context reduces completeness.

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

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

The input schema already provides descriptions for both parameters (org and cursor) with 100% coverage, so the baseline is 3. The description does not add any additional parameter meaning beyond what 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 uses the specific verb 'List' and identifies the resource as 'members of a Sentry organization,' clearly distinguishing it from sibling tools like list_projects or list_issues. It also enumerates the returned fields (user id, email, name, role, org role info), providing a precise scope.

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 lacks any guidance on when to use this tool versus alternatives. There is no mention of prerequisites, use cases, or exclusions; it simply states what the tool does, leaving the agent to infer applicability.

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 burden. It discloses the scope (authenticated user's access) and return fields, but does not explicitly mention pagination, rate limits, or side effects. 'List' implies read-only, and the cursor parameter is present in the schema, but the description could be more explicit about behavior.

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

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

The description is two concise sentences with no wasted words. It front-loads the action and provides the essential return fields.

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 list tool with one optional parameter and no output schema, the description provides sufficient context: what it lists, for whom, and what it returns. It could mention pagination to be more complete, but the schema covers the cursor parameter.

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

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

Schema description coverage is 100% with the single cursor parameter fully described. The description adds no additional parameter semantics, 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 clearly states the action 'List all Sentry organizations the authenticated user has access to', specifying the resource (organizations), scope (all accessible to user), and returning fields. This distinctively separates it from sibling tools that focus on issues, projects, releases, etc.

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 context is clear: use this to list organizations the user can access. There is no explicit 'when not to use' or comparison to alternatives, but the sibling tools cover different resources, so the intended usage is evident.

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

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

With no annotations, the description carries the full burden. It discloses the return fields (project slug, name, platform, id, and team assignments), which is useful. However, it does not mention pagination behavior despite the cursor parameter, nor does it explicitly state that this is a read-only operation or any other behavioral traits.

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

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

The description is two sentences, front-loaded with the core function, and contains zero unnecessary words. It is concise and well-structured.

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 list tool with two parameters and no output schema, the description covers the essentials. However, it misses pagination context despite the cursor parameter, which could mislead an agent into expecting all results in one response. The description is adequate but not fully 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?

Schema coverage is 100% with detailed descriptions for both org and cursor. The description does not add any parameter-specific meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool lists all projects in a Sentry organization, with a specific verb ('List'), resource ('projects'), and scope ('in a Sentry organization'). It also lists the return fields, which distinguishes it from sibling tools like list_organizations and list_teams.

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

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

The description implies usage when the user needs to list projects, but it provides no explicit guidance on when to use this tool versus alternatives like list_teams or list_organizations. There is no mention of exclusions or alternatives, so the guidance is only implicit.

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

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

With no annotations provided, the description carries the transparency burden. It does disclose the operation and returned fields, but it omits behavioral details like pagination via cursor, default limit of 25, and ordering. This is a moderate gap for a list tool.

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

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

The description is two short sentences, front-loads the main verb and resource, and includes only useful output-field information. No filler or redundant content.

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

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

For a simple list tool with a schema covering all parameters and output fields listed in the description, this is largely complete. It lacks explicit pagination behavior and alternative-tool guidance, but these are minor given the schema and tool simplicity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no extra parameter semantics beyond what the schema already provides; it simply states the operation and output 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 uses a specific verb ('List') and resource ('releases in a Sentry organization'), clarifying scope and clearly distinguishing this from the sibling 'get_release' tool. It also enumerates the returned fields, making the purpose unambiguous.

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

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

The description clearly implies a listing use case but provides no explicit guidance on when to prefer this over alternatives such as 'get_release'. It does not state any exclusions or mention pagination/query strategies, leaving usage largely implied.

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 of behavioral disclosure. It does mention the return fields (team id, slug, name, memberCount, isMember), which helps. However, it does not explicitly state that the operation is read-only, nor does it mention pagination behavior despite the cursor parameter, or any auth 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?

The description is a single sentence that is direct and to the point. It front-loads the core purpose and includes return fields without any extraneous wording. Every word earns its place.

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

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

The tool is relatively simple with two parameters, and the schema covers them fully. The description explains the return fields, which is helpful given no output schema. However, it omits usage context, pagination behavior, and any mention of when this tool should be preferred over siblings, leaving some gaps.

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

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

The input schema provides descriptions for both parameters (org and cursor) with 100% coverage. The description adds no parameter-specific information beyond what the schema already contains, so the baseline of 3 is appropriate.

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

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

The description clearly states 'List teams in a Sentry organization', specifying the verb and resource. It also mentions the return fields, which adds clarity. However, it does not explicitly differentiate from sibling tools like list_projects or list_organizations, so it lacks sibling 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?

The description provides no guidance on when to use this tool versus alternatives. It neither states when to use it (e.g., 'Use this to enumerate teams in an org') nor mentions any exclusions or alternative tools. There is no implied usage context beyond the basic function.

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 for behavioral disclosure. It adds the fact that a comment can be attached and paraphrases the status effects, but it does not disclose potential side effects (e.g., suppressing notifications), permission requirements, reversibility, or what response to expect after mutating the issue. This is a significant gap for a mutation tool.

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

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

One sentence, front-loaded with the core action, and every phrase earns its place. It communicates the action, the supported statuses, and the optional comment without any filler or repetition.

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 description is minimally viable for a tool with a rich schema (100% param coverage) and no output schema. It tells the agent what the tool does and what parameters matter, but it omits expected return behavior and operational caveats (permissions, idempotency, consequences). Given the moderate complexity and mutation nature, more context would be needed for full completeness.

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 parameter already well-documented (status enum descriptions, comment purpose, issue_id format). The description adds no new parameter-level details; it merely restates the status values in a more casual way. Baseline 3 is appropriate because 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?

The description uses a specific verb ('Change the status') and resource ('Sentry issue'), then enumerates the exact state transitions (resolve, unresolved, ignore, resolvedInNextRelease) and the optional comment. This clearly distinguishes it from the sibling list/get tools, all of which are read-only.

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

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

The description implies when to use the tool (whenever you need to mutate issue status) and lists supported statuses, but it does not explicitly discuss alternatives or exclusions. Since all sibling tools are read-focused, the usage context is inferred rather than stated, making it adequate but not exemplary.

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