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

Annotations already mark this as non-read-only and non-destructive, and the description reinforces that it creates an issue. It adds the workflow constraint that confirmPublish must be true after review, though the schema already encodes the const true requirement.

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

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

Two short sentences with the action first and the key constraint second. Every word earns its place; there is no redundant filler.

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 complex creation tool with 8 parameters, nested objects, and no output schema, the description is too sparse. It does not explain the expected return value, the relationship to jira_get_create_fields or jira_preview_issue, or what happens if additionalFields are invalid.

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 88%, so the schema already explains most parameters such as summary, projectKey, issueTypeId, and additionalFields. The description adds no significant parameter meaning beyond what the schema provides.

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 the core action 'Cria uma issue no Jira', with the verb 'Cria' clearly marking this as a creation tool. This distinguishes it from sibling tools like jira_update_issue and jira_preview_issue, though it does not explicitly contrast with them.

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

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

The phrase 'Exige confirmPublish: true após revisão' implies that the tool should be used after reviewing the issue and confirming publication. It gives no explicit when/when-not guidance or alternative tool names, so the usage context is only implied.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds the behavioral detail that it lists both available and required fields, which goes beyond the annotations and matches the read-only nature.

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 conveys the tool's purpose without any filler. Every word contributes meaning.

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

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

For a simple read-only tool with two parameters and no output schema, the description captures the essential purpose and scope. It could mention that the fields depend on the issue type, but 'para projeto e tipo' already implies this dependency.

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

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

Schema description coverage is 0%, so the description must compensate. It only loosely references 'projeto e tipo' without explicitly mapping to projectKey and issueTypeId or adding format/value guidance. Parameter names are somewhat self-explanatory, but the description adds minimal semantic value over the raw schema.

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

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

The description uses a specific verb (Lista) and a precise resource (available and required fields for creating an issue), scoped by project and issue type. This clearly differentiates it from sibling tools like jira_create_issue or jira_search_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 clearly states the context: retrieving fields needed when creating an issue for a given project and type. It does not name alternatives or explicitly say when not to use the tool, but the purpose is specific enough that an agent can infer the appropriate usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the nuance that only 'permitted' issue types are returned, but it provides no further behavioral context such as error handling for invalid project keys or response shape.

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

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

The description is a single front-loaded sentence with no redundant words or filler. Every word contributes to the tool's function and scope, making it easy for an agent to parse quickly.

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

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

For a simple one-parameter read-only tool, the description adequately states the input context and the nature of the output (a list of allowed issue types). Annotations cover the safety profile and the schema covers the parameter. Minor missing details like output format are not critical at this level of 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 description coverage is 100%, so the schema fully documents projectKey. The description's phrase 'projeto informado' merely echoes the parameter's purpose and adds no new semantic detail beyond the schema.

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

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

The description uses a specific verb ('Lista') and resource ('tipos de issue') scoped to a project, which clearly distinguishes it from sibling tools like jira_list_projects, jira_search_issues, and jira_get_create_fields. The project-scoping phrase makes the tool's unique function unmistakable.

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 (when you need the issue types allowed in a given Jira project), but it does not explicitly state when to use it over alternatives or mention any exclusions. There is no reference to sibling tools or a 'use this instead of X' condition.

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?

The readOnlyHint and destructiveHint annotations already cover the safety profile. The description adds useful behavioral context by specifying that results are limited to projects the account can view, which conveys permission-based scoping beyond what the annotations state.

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, straightforward sentence that gets directly to the point. It avoids redundancy and places the core action and resource upfront.

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, zero-parameter, read-only list tool, this description is complete. It states what is listed and the visibility scope, and the absence of parameters and output schema leaves little additional context for an agent to require.

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. There is nothing for the description to clarify beyond confirming that no arguments are needed, which the empty schema already demonstrates.

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 ('Lista') and resource ('projetos Jira'), and clearly scopes it to what the account can view. This distinguishes it from sibling tools like jira_search_issues or jira_create_issue, which target different operations.

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: when the agent needs the list of Jira projects accessible to the account. However, it does not explicitly state exclusions or alternatives, leaving usage guidance mostly implicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds a meaningful behavioral guarantee: the tool does not call Jira at all. This goes beyond the annotations and reassures the agent that this is a purely local computation with no external side effects.

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 concise sentence with no filler and the key distinguishing trait ('sem chamar o Jira') is front-loaded. It is efficient, though slightly terse.

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

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

With no output schema, the description should clarify what the generated fields look like and how they relate to jira_create_issue or jira_update_issue. It only says it generates fields, leaving the agent to infer return shape, validation behavior, and how to feed the result into the next step. For a 7-parameter tool with nested objects, this is insufficient.

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 86%, so the input schema already documents all significant parameters, including the nested additionalFields and parentKey. The description itself adds no parameter-level detail, but the schema carries the burden adequately.

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 behavior: 'Gera os campos que seriam publicados, sem chamar o Jira' clearly identifies a preview/generation action and explicitly notes that no Jira call is made, which distinguishes it from the create/update siblings. It does not name alternatives, but the core 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?

Usage context is only implicit: 'sem chamar o Jira' signals a safe dry-run/preview before publishing, and the siblings jira_create_issue and jira_update_issue strongly imply the intended workflow. However, there is no explicit statement of when to use this tool instead of alternatives, nor any direct reference to sibling tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat safety. The description adds only the duplicate-avoidance intent, not behaviors like result bounds or pagination behavior, but this is acceptable given the annotation coverage.

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

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

A single, front-loaded sentence that says the operation, scope, and purpose with no 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 read-only search tool with one required parameter and annotations covering safety, the description is nearly sufficient: an agent knows what to pass and why. It does not describe the return shape or JQL details, but the tool name and schema cover the essentials.

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

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

Schema description coverage is 0%, so the description must compensate. 'por JQL' clarifies what the jql parameter expresses, but maxResults is left to its name and schema constraints. This is partial compensation, not full.

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 ('Busca'), a resource ('issues existentes'), and a search method ('por JQL'), so an agent can tell this is existing-issue search. It does not explicitly contrast it with sibling tools like preview_issue or list_projects, but the JQL scope makes 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?

'para evitar duplicidade' provides a clear intended context: run this search before creating an issue to avoid duplicates. It does not state when not to use it or name alternatives, so it falls short of an explicit 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description is not required to restate safety. The addition of 'Exige confirmPublish: true' is useful behavioral context beyond annotations, but the description does not disclose side effects, whether fields are merged or replaced, or what happens after confirmation.

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 short, direct, and front-loads the core action in its first sentence. The second sentence adds the critical confirmation requirement without wasted words. It could be slightly more informative, but it is efficient.

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

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

For a tool with three required parameters, a nested object, and no output schema, this description is thin. It does not explain how to shape the fields object, what issueKey should look like, or what response or errors to expect. An agent would likely need to inspect other tools or examples to use 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%, so the description carries the burden of explaining parameters. It clarifies that 'fields' refers to issue campos and that confirmPublish must be true, but it does not explain the format of issueKey or the structure/keys expected inside the nested 'fields' object.

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 action ('Atualiza campos de uma issue existente') and the resource ('issue existente'), making the tool's purpose clear. It implicitly distinguishes itself from create, search, and preview siblings by focusing on updating fields of an existing issue, though it does not name alternatives explicitly.

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

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

The description gives no explicit guidance on when to use this tool versus siblings, such as jira_create_issue or jira_preview_issue. The phrase 'issue existente' implies this is for existing issues only, but there are no contextual conditions, preconditions, or exclusions stated.

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