Laraue Boards

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 does state the mutation effect ('adds') and the return value (new comment id), which is helpful. However, it does not disclose permission requirements, error behavior, or any side effects beyond the basic action, leaving a moderate gap for a write 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?

The description is a single, front-loaded sentence with no wasted words. It states the action, the target, and the return value efficiently, earning every word.

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 2-parameter tool with full schema coverage and no output schema, the description is largely complete. It covers the return value, which is the only behavioral output an agent needs. It lacks explicit sibling routing, but that gap is already accounted for in usage_guidelines and does not significantly undermine safe invocation in this 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 100%, with both issueKey and text already well-defined. The description adds no parameter-specific detail beyond what the schema provides, so the baseline score 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 states a specific verb and resource ('Adds a comment to an issue') and adds the return outcome ('returns the new comment's id'). It clearly distinguishes from siblings like edit_comment (add vs. edit) and create_issue (comment vs. issue) without needing to open their schemas.

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 explicit guidance on when to use this tool versus alternatives. It does not mention edit_comment or any condition that would select add_comment over other siblings. Usage is only implied by the verb 'adds', which is insufficient for clear decision-making.

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 must carry the burden of behavioral disclosure. It states the core mutation (creates an issue) and a key result (returns key), which is the primary behavior. However, it does not disclose any side effects (e.g., whether it modifies other data), permission requirements, or error behavior. It is adequate but not rich, and does not contradict any annotations.

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

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

The description is a single, compact sentence that front-loads the primary action ('Creates a new issue') and essential output ('returns its key'). Every word earns its place; there is no redundant or filler content, and the structure is clean and direct.

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 that there is no output schema, the description's mention of returning the key is valuable. It also implies the need for prerequisite setup via the parameter descriptions (e.g., statusId must come from list_statuses), which are covered in the schema. The description is complete enough for a straightforward create operation, though it does not describe error handling or response formatting beyond the key.

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% – every parameter has a description. The tool description adds no new parameter-level semantics; it only notes the output (key), which is not a parameter. Since the schema fully documents parameters, the baseline of 3 is appropriate, and the description does not go beyond it.

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 ('Creates'), a clear resource ('a new issue'), and the output ('returns its key'). It distinctly separates this tool from siblings like edit_issue, get_issue, and update_issue_status, making the tool's 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 use for creating new issues, and the presence of sibling tools (edit_issue, get_issue) provides context that this is the creation entry point. However, it does not explicitly state when NOT to use it (e.g., 'use edit_issue to modify existing issues') or list alternatives, so it lacks explicit exclusion 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 present, so the description carries the full burden. It discloses the key behavioral constraint that only the author can edit, but does not cover other aspects like idempotency, failure modes, or whether edits are reversible. Adequate but not comprehensive.

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

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

Two sentences, front-loaded with the action and then the key constraint and source of the id. Every word earns its place; no 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 2-parameter tool with full schema coverage, the description covers the essential behavior, the author restriction, and how to obtain the id. It does not explain return values, but none are expected, and no output schema exists. Minor gaps like error handling are acceptable for this 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%, and the schema already describes both parameters clearly. The description adds little beyond referencing get_issue for the comment id, which is more usage guidance than parameter semantics. 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?

States a specific verb and resource: 'Edits a comment's text.' It clearly distinguishes from siblings like add_comment (creating) and edit_issue (editing an issue), and the author constraint adds further specificity.

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?

Provides a clear prerequisite by pointing to get_issue for obtaining the comment id and mentions the author-only restriction, which guides when this tool applies. It does not explicitly list alternatives, but the sibling names make the distinction obvious.

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

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

With no annotations, the description must disclose behavioral traits itself; 'Replaces' signals that old content is overwritten, but it does not mention side effects on attributes, permissions, or return behavior. The schema discloses the attribute default, but the free-text description adds little beyond the mutation verb.

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

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

The description is a single front-loaded sentence with no filler. It states the action and object directly, earning 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?

All parameters are documented in the schema, and the tool's core action is clear, so an agent could invoke it correctly. However, there is no output schema and no description of the result or failure conditions, leaving a moderate gap for a mutation 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 description coverage is 100%, so the parameters are already well documented. The description adds only the phrase 'text content,' which roughly maps to the content parameter and does not improve on the schema's explanation.

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 ('Replaces') and names the target resource ('an issue's text content'), making it easy to distinguish from edit_comment and update_issue_status. It is slightly incomplete because it omits the tool's ability to update attributes, which is part of the input 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?

No guidance is given about when to choose edit_issue over create_issue, edit_comment, or update_issue_status. The description implies use for modifying an existing issue's content, but it never states that, notes prerequisites, or names 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?

No annotations are provided, but 'Gets' makes clear this is a read-only retrieval, and 'full content and comments' specifies the return scope. It does not discuss auth, errors, or edge cases like missing keys, though for a simple get-by-key tool this is generally sufficient.

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 tightly worded sentence with an example; no filler. The key operation and scope are front-loaded.

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

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

For a low-complexity single-key tool, the description provides the necessary input and return context even without an output schema or annotations. It omits not-found/error behavior but that is minor for this 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 already covers the only parameter with the same example, so the description adds little beyond restating the key format. The 100% schema coverage means the description doesn't need to compensate.

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 ('Gets') and resource ('one issue's full content and comments') and identifies the input key with an example. This clearly distinguishes it from sibling list_issues (which returns multiple) and comment mutation tools.

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

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

Implies use for retrieving a single issue's details, but does not explicitly say when to prefer it over list_issues or how it relates to comment tools. No exclusions or alternative routing 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 provided, the description carries the burden of behavioral disclosure. It clearly indicates this is a read-only list operation, scopes results to the caller's organization, and discloses the composition of returned data (name, type, allowed values). It does not discuss pagination or empty-result behavior, but for a zero-parameter list tool this is sufficient.

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, information-dense sentence. Every clause earns its place: it names the resource, scopes to the caller's organization, enumerates returned fields, and connects to the consuming tools. No filler or redundancy.

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

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

For a tool with no input schema, no output schema, and no annotations, the description covers the essential context: what is returned, the scope, and how the result is used. It stops short of specifying the exact response structure, but the described details are likely enough for an agent to call and interpret the 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?

The tool has zero parameters, so the baseline is 4. The description confirms no inputs are needed and instead focuses on what the response provides. This is appropriate and needs no additional parameter-level detail.

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 ('Lists'), a specific resource ('the caller's organization's custom issue attributes'), and the exact contents returned (name, type, allowed values). It also ties the output to create_issue/edit_issue's attributes map, which clearly differentiates it from sibling tools like list_issues and list_statuses.

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 implicitly tells the agent when to use this tool: before calling create_issue or edit_issue to know what attribute keys/values are accepted. It does not explicitly state when not to use it or name alternatives, but the connection to create_issue/edit_issue is clear enough to guide selection.

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 and does so well. It discloses the 50-item page limit, optional count, ordering by most recently updated, and the hasNextPage mechanism for pagination, giving the agent a solid model of the tool's runtime 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 sentences with no filler: purpose and filters come first, followed by pagination behavior and the key pagination signal. Every sentence earns its place and the structure is easy to scan.

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 listing tool with no annotations and no output schema, the description is complete enough: filters, page size, ordering, and how to paginate are all covered. An agent can correctly invoke the tool and interpret the result flow.

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 fully documents page, count, spaceKey, statusName, and assigneeName. The description adds a useful summary of filter meaning and pagination behavior but does not need to compensate for missing parameter documentation.

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 issues in the caller's organization and names the available filters, so an agent knows what resource is being operated on. It does not explicitly contrast itself with sibling tools like get_issue, but the difference between listing issues and retrieving a single issue is strongly implied by the name and description.

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 for when to use the tool: when you need a paginated, filterable list of issues. It does not explicitly state when not to use it or point to alternatives such as get_issue for a single issue, leaving the choice somewhat 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?

There are no annotations, so the description carries the behavioral disclosure burden. It reveals a read-only listing behavior and the grouping by epic, which is useful. However, it does not mention permissions, whether archived/inactive statuses are included, or how results are ordered — a modest gap for a simple 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?

A single, compact sentence that front-loads the core purpose and then immediately adds the most decision-relevant detail about how the result is used. No filler or repetition of schema 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 one-parameter, no-nested-objects listing tool without annotations, the description gives enough essential context: what is listed, how it is grouped, and why the returned IDs matter. It doesn't describe the exact return payload, but for this simple tool the absence is not critical.

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 schema already documents the only parameter, spaceKey, with an example. The description adds context for the output (status IDs usable by create_issue/update_issue_status) but does not enrich the meaning of the parameter itself, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Lists'), names the exact resource ('statuses available in a space'), and adds the grouping detail ('by epic'). It also states the practical purpose of the output — IDs that create_issue/update_issue_status accept — which makes the tool's role unmistakable relative to siblings.

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 signals when this tool is useful: before calling create_issue or update_issue_status, since it returns the status IDs those tools accept. It does not explicitly exclude alternatives or name a when-not-to-use case, but the context is clear enough for an agent to route correctly.

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 of behavioral disclosure. While 'updates' implies a mutation, it does not state side effects, required permissions, reversibility, or error behavior. For a write operation, this is a notable 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?

Two concise sentences, front-loaded with the action and immediately followed by the critical prerequisite. Zero wasted 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 simple two-parameter tool with no output schema, the description is nearly complete. It provides the essential usage step. It lacks explicit mention of return behavior or edge cases, but those are minor for a straightforward update operation.

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 both parameters are already well documented. The description adds nothing beyond what the schema provides (e.g., it mentions 'from list_statuses' but that is also in the schema). Baseline 3 applies since 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 'Updates', the resource 'an issue's status', and the method 'by id'. It distinguishes this from siblings like edit_issue, which likely edits other fields. The purpose is unambiguous.

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

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

It explicitly instructs the agent to call list_statuses first to find the target status id, providing a concrete prerequisite for correct usage. This is strong guidance that prevents misuse.

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