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 says 'save' but does not disclose whether saves require auth, whether duplicate titles are allowed, whether content is indexed/searchable afterward (relevant given search_context), or what happens on conflict. For a mutation tool with zero annotation coverage this is a substantial 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?

One sentence, front-loaded with the verb and resource, with no filler. It is efficient, though it is somewhat generic and spends its words on purpose rather than on operational detail.

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 8 parameters (2 required), nested metadata, two enums, no output schema and no annotations, the description should do more: it never mentions what is returned (e.g., a context ID), how optional fields like related_entity_id are used, or the default context_type behavior. It is too thin 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 description coverage is 100%, so the schema already explains all 8 parameters including enums and the nested metadata object. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (save) and resource (conversation context, chat summaries, knowledge) plus the outcome (preserve understanding across sessions). It is clear what the tool does, but it does not differentiate itself from close siblings like create_summary or update_context, which the agent would have to distinguish on its own.

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 rationale 'to preserve understanding across sessions' implies the general situation for use, but there is no explicit when-to-use vs when-not, no mention of create_summary/create_issue alternatives, and no prerequisites. Usage guidance is inferable but not 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?

No annotations are provided, so the description carries the full burden. It does not state whether the epic is immediately persisted, what the response contains (e.g., new epic id), whether duplicate names are allowed, or any auth/permission requirement 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?

A single front-loaded sentence with no filler, though it is arguably too terse for a creation tool that could use a clause about the resulting epic.

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 5-parameter mutation tool with no annotations and no output schema, the description says nothing about the created resource, required permissions, or what happens on failure. It leaves the agent without enough behavioral context to call it confidently.

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 enums and defaults documented, so the baseline is 3. The parenthetical '(idea)' hints that the default status matches the 'idea' enum value, adding a small amount of meaning but nothing the schema doesn't already imply.

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 ('epic') scoped to a project, which cleanly separates it from create_issue and create_story. It does not, however, explicitly contrast itself with those siblings, so it falls short of the top tier.

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 create an epic versus a story or issue, no prerequisites (e.g., the project must exist), and no mention of alternatives. 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. It implies a write operation but does not disclose permissions, side effects, required fields, defaults, or whether creation is reversible. For an 11-parameter mutation tool, this is a significant transparency 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?

A single front-loaded sentence with no wasted words. It is efficient, though very terse for an 11-parameter mutation tool, and offers no additional structured context.

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 11 parameters, no annotations, no output schema, and a create/mutation operation, the description is too sparse. It omits required fields, defaults, response behavior, and any caveats an agent would need before invoking 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?

Schema description coverage is 100%, so all 11 parameters, including enums and defaults, are already documented in the schema. The description adds no parameter-level meaning, syntax, or constraints beyond that, making the baseline 3 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?

States a specific verb ('Create') and resource ('issue/bug') scoped to a project, which lets an agent distinguish it from sibling creation tools like create_epic and create_story. However, it does not explicitly name those alternatives or further differentiate 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?

Provides no guidance on when to use this tool versus alternatives such as create_epic or create_story, and no prerequisites (e.g., project_id required) or exclusions. Usage is only implied by the tool and resource names.

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 almost nothing beyond the write operation. It does not mention permissions/auth, whether name must be unique, whether the operation is reversible, or what side effects occur. The only extra context is that projects organize epics and stories, which is conceptual rather than behavioral.

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

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

A single short sentence with zero filler and the create action front-loaded. It is appropriately sized for a simple creation tool. Nothing is wasted or buried.

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 mutation tool with no annotations and no output schema, the description is too thin. It omits when to use it, prerequisites, uniqueness or validation behavior, and what the response provides (e.g., the new project ID). The schema covers parameters, but the description should at least cover behavioral and usage context for created objects.

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 name, status (with enum), and description. The description adds no parameter-level meaning, syntax, or constraints beyond what the schema provides. Baseline 3 is appropriate 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?

The description states a specific verb+resource ("Create a new project") and adds a rationale ("to organize epics and stories") that clarifies what the resource is for. It distinguishes itself from read/update/delete project siblings by the create verb, though it does not explicitly name alternatives like create_epic or create_story. Clear and actionable, but lacks explicit 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?

No guidance on when to use this tool versus alternatives. It does not say whether a project must exist before creating epics/stories, nor how it relates to create_epic or create_story. The agent is left to infer usage entirely.

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 does not say whether the call requires permissions, whether duplicate titles are allowed, whether an existing period can be overwritten, or what the call returns. Only the mutation intent ('create') 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?

A single front-loaded sentence with the core action first and no filler. Appropriately sized for its 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 9-parameter creation tool with nested metadata, two enums, and no output schema, the description covers the bare minimum. The schema fully documents inputs, but the absence of annotations means the write semantics and return behavior are left entirely 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 coverage is 100%, so every parameter including the two enums and the nested metadata object is already documented in the schema. The description adds no format, constraint, or relationship detail beyond that baseline.

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

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

Specific verb+resource: 'Create a status update/report' with a stated intent (track progress, blockers, achievements). It distinguishes itself from CRUD siblings by name, but the description never explicitly contrasts with update_status_update or create_summary, so no credit for 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?

No when-to-use guidance, no exclusions, and no routing to alternatives such as update_status_update for edits or create_summary for a different artifact type. The phrase 'to track progress, blockers, or achievements' hints at intent but is not actionable 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 supplied, so the description carries the full behavioral burden. It implies a write operation but says nothing about permissions, what happens if epic_id does not resolve, whether defaults are applied, or what side effects occur on the epic.

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 zero filler and the resource named first. It is efficient, though the terseness borders on under-specification for a 7-parameter mutation 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?

There is no output schema and no annotations, so the description must cover behavior and returns; it does neither, leaving an agent unaware of what the created story looks like or what identifiers come back.

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 including enums and defaults is already documented in the schema; the description adds nothing beyond the loose hint that epic_id links to a parent epic. Baseline 3 applies 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 ('Create') and resource ('a new story') plus its containment scope ('within an epic'). It does not, however, differentiate itself from nearby siblings like create_issue or create_epic, which an agent must infer from resource names 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?

The description gives no when-to-use guidance, no prerequisites (e.g. the parent epic must already exist), and does not point to update_story or create_issue as alternatives. Usage is only implied by the tool 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. It does not state whether the summary is immediately searchable, who can read it, whether titles must be unique, or what happens to the optional related_entity link. 'Create' implies mutation but no mutation semantics (reversibility, permissions, side effects) are disclosed.

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

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

A single compact sentence with the verb and resource front-loaded and no filler. It is efficient, though the trailing content examples are vague enough to be of limited value.

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

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

For a 7-parameter tool with nested objects, enums, no output schema, and no annotations, the description is thin. It omits how the enum categories differ, how related_entity_id/type are used, and what the call returns, leaving real gaps an agent must guess at.

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 all seven parameters are already documented in the schema, making the baseline 3 appropriate. The description adds no extra meaning about summary_type values, tag matching behavior, or metadata handling beyond what the schema 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?

States a specific verb ('Create') and resource ('summary/note') and hints at intended content (decisions, AI-generated content). It does not differentiate from close siblings like create_context or create_status_update, which also capture free-form content, so an agent cannot fully disambiguate without opening 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?

There is no guidance on when to use this versus update_summary, create_context, or create_status_update, nor any prerequisite or deduplication advice. The clause 'to track important information, decisions, or AI-generated content' gestures at intent but is not a when-to-use rule.

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, yet all it discloses is that a deletion occurs. It says nothing about irreversibility, required permissions, whether related records cascade, or whether the deletion can be undone — all critical for 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?

A single front-loaded sentence with zero filler; the operation is stated immediately. It is efficient, though its brevity reflects under-specification rather than disciplined 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?

The schema is simple and fully documented, and no output schema is needed for a delete, so the input side is covered. The remaining gap is the absence of any behavioral warning for a destructive tool with no annotations — the definition is minimally viable but not safe to invoke blindly.

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%: context_id is fully documented as 'UUID of the context to delete'. The description adds no format, source, or lookup guidance beyond the schema, 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 states a clear verb (delete) and resource (context entry), so the operation is unambiguous. However, it is essentially the tool name expanded by one word, adding no scope detail (permanent vs. archival, single vs. bulk) and no differentiation from sibling mutation tools like update_context or delete_summary.

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 update_context, search_context, or any other sibling, and no prerequisites or exclusions are stated. The usage is only implied by the word 'delete', which is not enough for an agent choosing among 40 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?

With no annotations, the description carries the full burden, and it does disclose a critical trait: the delete cascades to all associated stories. However, it omits irreversibility, required permissions, and whether the deletion is permanent, which an agent needs for 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?

A single front-loaded sentence with zero waste that conveys both the action and the cascade effect. Appropriately sized for a one-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?

The cascade disclosure is the most important behavioral fact and it is present, but for a destructive tool with no annotations and no output schema, the absence of any note on permanence or required permissions leaves an important gap.

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

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

Only one parameter with 100% schema description coverage ('UUID of the epic to delete'), so the schema fully documents it. The description adds no parameter detail, 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?

Clear verb (Delete) + resource (epic), and it explicitly states scope: the epic plus all associated stories. An agent can distinguish it from delete_issue/delete_story by resource. It does not name a sibling directly, but the resource term 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?

No guidance on when to use this versus delete_story or delete_issue, no prerequisites, and no warning conditions. The description describes what it does but not when an agent should choose it or what state must hold beforehand.

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. The verb 'delete' implies a destructive mutation, but there is no statement about permanence/irreversibility, whether child items cascade, or what authorization is required — all critical for a destructive tool with zero 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?

Three words, front-loaded with the verb, zero padding or repetition. It is terse rather than verbose; the brevity is efficient even if it reflects thin 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 destructive single-parameter tool with no annotations and no output schema, the description is inadequate: it omits what happens on success, whether the deletion is reversible, and any side effects or permission requirements. Given the simplicity of the tool this is not catastrophic, but the safety-relevant gaps remain.

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

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

Schema description coverage is 100%, and the single parameter (issue_id, UUID of the issue) is fully documented in the schema. The description adds nothing beyond this, so the baseline of 3 applies when the schema does all 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 (delete) and resource (issue), so the agent knows exactly what operation it performs. However, it does no work to distinguish itself from the many sibling deleters (delete_context, delete_project, delete_epic, delete_story, delete_summary), so the naming alone carries the 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 delete versus close/update an issue, no prerequisites (e.g., permissions, resolved state), and no reference to any alternative tool. 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?

With no annotations provided, the description carries the full burden. It does disclose the important behavioral trait that deletion cascades to epics and stories, which is genuinely useful. However, it omits irreversibility, required authorization, and any error behavior, which matter for 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?

A single, front-loaded sentence with zero filler that conveys both the action and the cascade consequence. Nothing is wasted and nothing important is buried.

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 delete tool with a fully documented schema and no output schema, the description is nearly sufficient, and the cascade disclosure is the key piece of context. It would be complete with a note on irreversibility and whether dependent data must be removed first.

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 single project_id parameter is fully documented in the schema (UUID of the project to delete) at 100% coverage, so the baseline is 3. The description adds no format, constraint, or lookup guidance 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?

States a specific verb (Delete) and resource (project) and adds the cascade scope (associated epics and stories), which an agent cannot infer from the name alone. It does not explicitly route to the sibling delete_epic/delete_story for narrower deletions, so it stops short of full 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?

There is no when-to-use vs when-not guidance: nothing tells the agent to prefer delete_epic/delete_story for partial cleanup, and no prerequisites, permission requirements, or confirmation steps are mentioned. Usage is only implied by 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. It does not disclose whether deletion is permanent, whether it cascades to related data, whether permissions are required, or what is returned, all of which matter for 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?

A single front-loaded sentence with no wasted words. It is efficient, though the brevity contributes to the gaps in other dimensions rather than compensating for them.

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 destructive mutation with no annotations, no output schema, and many similar siblings, the description is too thin. An agent cannot tell whether the delete is reversible, cascading, or gated by permissions.

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

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

Schema description coverage is 100% and the single parameter's UUID purpose is fully documented in the schema, so the description adds no parameter meaning beyond what is already structured. Baseline 3 applies.

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

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

States a specific verb (Delete) and resource (status update), so the agent knows the operation exactly. It does not differentiate from the many parallel delete_* siblings or reference alternatives, but the resource name itself distinguishes it.

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 update_status_update or the other delete_* tools. The condition for choosing deletion is left entirely to inference.

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 says nothing about irreversibility, permission requirements, cascade effects on child records (e.g. linked issues or contexts), or error behavior when the story_id 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?

Three words, fully front-loaded with the verb and resource, with zero filler. It is efficient, though so terse that it leaves the behavioral gaps noted elsewhere unfilled.

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 destructive, irreversible operation with no annotations and no output schema, the description is incomplete: it does not warn that deletion is permanent, mention permissions, or describe what happens to dependent records. The simple one-parameter schema limits the damage, but a delete tool needs more than this.

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% — the single story_id parameter is already documented as the UUID of the story to delete. The description adds no format or constraint information beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Delete) and resource (a story), so the action is unambiguous. However, it does not distinguish itself from the many sibling delete tools (delete_issue, delete_project, delete_epic, delete_summary, delete_context) beyond the resource name already implied by the tool 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?

The description gives no indication of when to use this tool versus alternatives, nor any prerequisites, conditions, or confirmations required. Usage is only inferred from the tool name and the fact that a story_id must be supplied.

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. 'Delete' implies a destructive mutation, but the description says nothing about permanence, reversibility, required permissions, or cascading effects on related objects. This is a significant gap for 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?

The description is a single short sentence with no wasted words, but brevity here reflects under-specification rather than efficient communication. It is neither bloated nor adequately 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?

For a destructive, unannotated tool with no output schema, the description should at minimum note irreversibility, error behavior for a missing UUID, or permission requirements. It covers none of these, leaving the agent with only the name and schema to work from.

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

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

Schema description coverage is 100% and the single parameter 'summary_id' is fully documented in the schema as the UUID of the summary to delete. The description adds nothing beyond this, 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 states a verb and resource ('Delete a summary'), so the basic action is unambiguous. However, it essentially restates the tool name and gives no differentiation from the many other delete_* siblings (delete_context, delete_issue, delete_project, etc.). It is minimally viable rather than clarifying.

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, no prerequisites, and no warning about consequences. The agent must infer that this is the way to remove a summary from the sibilng set, with no explicit routing help.

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 disclosure burden. 'Get' implies a read, but there is no mention of behavior when the ID does not exist, permission requirements, or the shape/size of the returned entry. For a tool with zero annotation coverage 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?

A single short sentence with no filler, front-loading the verb and resource. It is efficient, though its brevity contributes to the gaps in usage and behavioral detail.

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 read tool this is minimally adequate, and no output schema exists so the agent gets no structural view of a 'context entry'. The description would benefit from one clause on what a context entry is or when the ID lookup fails.

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% — context_id is documented as a UUID — so the schema already does the heavy lifting. The description adds only the generic phrase 'by ID' and nothing about format or where the ID comes from, so baseline 3 applies.

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

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

States a specific verb and resource ('Get a specific context entry') plus the lookup key ('by ID'), which distinguishes it from list_context and search_context. It stops short of naming those siblings as alternatives, so it is clear but not fully differentiated.

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 'by ID' implies the precondition of already knowing the identifier, but the description never states when to use this versus search_context or list_context. No explicit when-to-use or when-not-to-use guidance is 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?

No annotations exist, so the description carries the full behavioral burden. 'Get' implies a read, but it says nothing about permissions, behavior on an unknown/invalid epic_id (error vs empty), or whether the story list is paginated or truncated.

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 verb and resource and immediately qualified by the returned scope. No 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?

With no output schema, the description is the only source of return-shape information; it does say stories are included, which is valuable, but says nothing about nesting depth, pagination, or the shape of the epic fields themselves.

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 single epic_id parameter is documented as a UUID in the schema. The description adds no format or sourcing detail beyond that, so the baseline 3 applies.

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

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

States a specific verb (Get) and resource (epic), and adds scope detail — 'including all its stories' — which distinguishes it from get_story and list_epics. It does not name a sibling explicitly, so it lands just short of a 5.

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 list_epics, get_issue, or get_project_summary, and no stated prerequisites such as needing a valid epic UUID. Usage is only implied by the tool name and the required epic_id.

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 for a read tool. Read-only behavior is inferable from 'Get', but nothing is said about miss/not-found behavior, required auth, or permissions. For a trivial lookup this is a tolerable but real 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?

One short, front-loaded sentence with zero filler. The verb, resource, and retrieval key are all present immediately.

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 with a complete schema, this is minimally adequate. With no annotations and no output schema, the description does not explain what an issue object contains or what a lookup failure looks like, leaving the agent to infer the result shape.

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

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

Schema description coverage is 100% and the single parameter (issue_id as a UUID) is fully documented in the schema. The description adds no format or constraint detail beyond 'by ID', so the baseline 3 applies.

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

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

States a specific verb (get) and resource (issue) plus the retrieval key (by ID), which cleanly separates it from list_issues and search_issues. It stops short of explicitly contrasting itself with those siblings, so it doesn't reach the top of the scale.

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

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

Usage is only implied: fetch a single issue when you already have its ID. There is no explicit when-to-use or when-not-to-use guidance, and the sibling set (list_issues, search_issues, get_summary) offers real alternatives that the description never acknowledges.

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 usefully discloses that the response embeds nested epics and stories (behavior not visible in the input schema), but it says nothing about authorization, error cases (e.g., unknown UUID), response size, or whether the nested data is paginated.

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 front-loaded sentence with the resource and scope up front and zero filler. Nothing is redundant or buried.

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 tool with no annotations and no output schema, the description covers the gist (project plus nested epics/stories) but omits permission requirements, failure behavior, and any disambiguation from get_project_summary. Adequate but with clear 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?

Schema coverage is 100%, so the single project_id parameter is already fully documented as a UUID in the schema. The description adds no format, constraint, or lookup-caveat details beyond that. Baseline 3 applies 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 ('Get') and resource ('a specific project') and adds scope ('including all its epics and stories'). It is clear on its own, but it does not differentiate itself from closely related siblings such as get_project_summary, so an agent cannot be fully sure which to pick.

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 alternatives (e.g., get_project_summary, list_projects, list_epics). The agent must infer usage 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?

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a safe read and the description does disclose the shape of the result (epic and story counts per project), which is useful, but it says nothing about permissions, cost, or whether the aggregation is expensive or live.

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

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

A single front-loaded sentence with no filler — the resource and the returned content both appear immediately. Nothing wasted.

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

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

With no output schema, the description must convey return values, and it does so at the level of 'counts of epics and stories' per project. The phrase 'comprehensive summary' remains vague about the remaining fields, but for a zero-parameter read tool this is close to adequate.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline for a parameterless tool applies. The description correctly implies no inputs are needed by framing the call as a global aggregate.

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 gives a specific verb ('Get'), resource ('projects'), and scope ('all projects'), plus the payload ('counts of epics and stories'). It is clear what the tool returns, though it does not explicitly distinguish itself from the sibling get_summary, which appears to serve a similar summarization role at a different 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?

There is no statement of when to use this tool versus the many sibling summary/project tools (get_summary, list_summaries, get_project). The scope word 'all projects' hints at the use case, but no alternatives or exclusions are named, leaving the agent to infer routing.

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 and does not deliver. It never states this is a read-only, non-mutating call, nor what happens on an unknown/malformed ID, nor any auth or rate-limit 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?

A single compact sentence with no waste, and the identifying key is front-loaded. It is efficient but too thin to be considered a model of structure.

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 read tool this is roughly adequate, but with no output schema and no annotations the description leaves the return shape and error behavior entirely unexplained.

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 there is a single parameter, so the schema already documents status_update_id as a UUID. The description adds only 'by ID', which is redundant with 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?

States a specific verb (get) and resource (status update) with the lookup key (by ID). It implicitly distinguishes itself from list_status_updates and search_status_updates by the 'specific/by ID' phrasing, but never names those siblings 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?

Usage is only implied: an agent infers this is the tool for fetching one known status update, versus the list/search siblings. There is no explicit when-to-use, when-not-to-use, or prerequisite (e.g. that a valid UUID must already be known).

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 and no output schema, so the description carries the full burden yet only says 'detailed information' without disclosing what fields are returned, whether it errors on a missing UUID, or any permission requirements.

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

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

A single short sentence with no filler or redundancy. It is efficient, though it is terse to the point of under-specification rather than optimally 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?

For a one-parameter read tool this is minimally viable, but with no annotations and no output schema the definition should hint at what 'detailed information' includes or how failures are handled. The gaps are modest given the tool's 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% for the single required story_id, so the baseline is 3. The description adds no meaning beyond the schema's own documentation of story_id.

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

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

It clearly states a specific verb (get) and resource (story) with a scope qualifier ('detailed information'), so an agent understands the operation. However, it does not distinguish this from adjacent getters like get_issue, get_epic, or get_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 over list_stories, search_issues, or other getters, and no prerequisites or exclusions are stated. The agent must infer the retrieval use case 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?

No annotations are supplied, so the description carries the full disclosure burden, yet it says nothing about permissions, error behavior when the ID does not exist, or what a returned summary contains. The only behavioral signal is the implied read-only nature of 'Get'.

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

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

A single short sentence with no filler, and the key scoping detail ('by ID') is front-loaded. It is terse to the point of under-specification rather than bloated.

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 lookup with a fully documented schema this is minimally adequate, but with no output schema and no annotations the description should at least hint at the return shape or failure mode. It leaves the agent to guess what comes back.

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 single parameter is fully documented in the schema (UUID of the summary), so schema coverage is 100% and the baseline of 3 applies. The description adds nothing beyond the schema, not even confirming the ID format.

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 ('Get') and resource ('summary') with the retrieval key ('by ID'), so the basic operation is unambiguous. However it does nothing to distinguish this from close siblings such as get_project_summary or list_summaries, and it never says what a 'summary' entity actually is.

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

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

There is no when-to-use guidance, no mention of the alternative retrieval tools (list_summaries, search_summaries, get_project_summary), and no preconditions. The agent must infer from the name alone that this is the single-record fetch.

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 does not state the return shape (array vs paginated envelope), whether results are ordered, whether an empty filter set means 'all', or any permission requirement. Only the schema's default limit of 50 hints at pagination.

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

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

A single tight sentence with the resource and filter capability front-loaded; nothing is wasted. It is short to the point of under-specification rather than bloated, so it scores well on structure alone.

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 filterable list tool with four optional parameters, no annotations, and no output schema, the description omits return format, ordering, and how it differs from search_context. An agent can call it from the schema alone, but disambiguation and result expectations are left to inference.

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 each parameter (tag, limit, context_type enum, related_entity_id) is documented in the schema itself, so the baseline of 3 applies. The description's phrase 'optional filters' adds only token-level context and no syntax, semantics, or combination rules 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 states a specific verb (List) and resource (saved context entries) with a hint at filter capability, so the agent knows what the tool returns. It does not, however, distinguish this from the sibling search_context, which is a near-neighbor in the same resource family.

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' gestures at usage but gives no when-to-use guidance, no exclusions, and no direction to search_context when full-text matching is needed versus plain enumeration here. For a tool with overlapping siblings, this is a real gap.

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 pagination, result caps, ordering, or permissions. 'List all' hints at an unbounded read but doesn't confirm it, leaving key read-side behavior undocumented.

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 zero filler; the operation and scope arrive immediately. It is efficient, though it is terse enough that brevity shades into under-specification.

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 read tool this is minimally adequate: purpose and scope are stated. With no output schema, the description would ideally describe the shape or volume of results and pagination, neither of which is covered.

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 both parameters and the status enum are already fully documented in the schema. The description adds only high-level scoping ('for a specific project') and no detail on filter interaction or defaults, which matches the baseline 3 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?

Specific verb 'List' plus resource 'epics' scoped to 'a specific project', which tells an agent exactly what it returns. It does not, however, distinguish itself from neighbors like get_epic (single) or list_issues/list_stories (other hierarchies), 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?

The description gives no when-to-use guidance, no indication of when to prefer get_epic or list_stories, and no prerequisites. An agent must infer the retrieval use case 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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose pagination, ordering, default result count, permissions, or what happens when filters return nothing — the only behavioral hint is that filters are optional.

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 efficient sentence with the resource and scope front-loaded and zero filler. It is arguably too terse for a seven-parameter tool, but nothing is wasted.

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

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

For a seven-parameter listing tool with no annotations and no output schema, the description is thin. It also creates mild tension by saying 'for a project' while project_id is not a required parameter, leaving the agent unsure whether an unscoped listing is valid.

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 all seven parameters (tag, limit, status, severity, issue_type, project_id, assigned_to) are already documented in the schema. The description adds nothing beyond restating that filters exist, which is the correct baseline 3 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 issues') plus the scoping context ('for a project') and the filter capability. It does not, however, distinguish itself from the sibling search_issues, which an agent would need in order to choose between the two.

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 indication of when to use this versus search_issues, get_issue, or any other sibling. 'Optional filters' hints at use but offers no context, prerequisites, or boundaries.

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 says nothing about pagination, result ordering, limits, or the shape of what is returned. It doesn't even explicitly confirm this is a read-only operation; the agent must infer that from the 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?

A single front-loaded sentence with no waste, and the optional-filter detail is placed right after the core action. It is efficient, though very terse given the lack of behavioral context.

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, zero-required-parameter listing tool with a fully documented schema, the description is minimally sufficient. It leaves open whether results are paginated or unbounded and has no output schema to fill that gap.

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

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

Schema description coverage is 100% and the single status parameter is fully documented with its enum values in the schema. The description only restates that the filter is optional, adding no syntax or semantic detail beyond the schema, 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?

States a specific verb (list) and resource (projects) plus the filtering scope, so an agent can distinguish it from get_project/create_project/update_project. It stops short of naming sibling tools, so differentiation relies on the naming convention rather than the text.

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 when-to-use guidance, no mention of alternatives like get_project for a single project, and no exclusions. Usage is only implied by the verb 'List'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read operation through the verb 'List' but does not state whether authentication is needed, how pagination works beyond the schema's 'limit' parameter, what the return shape looks like, or whether the result is sorted.

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, which is appropriate for a simple list tool. It is efficient, though its brevity contributes to gaps addressed in other dimensions rather than being a structural flaw itself.

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 fully documented schema and no output schema, the bare description is minimally functional. However, it omits any differentiation from 'search_status_updates' and provides no behavioral or usage context, leaving the agent with avoidable ambiguity when choosing between sibling tools.

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 all four parameters (tag, limit, status_type, related_entity_id) are already documented in the schema. The description's only parameter-related phrase, 'with optional filters', adds no meaning beyond what the schema provides, 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 states a clear verb ('List') and resource ('status updates'), making the operation immediately understandable. It does not, however, distinguish this tool from the sibling 'search_status_updates', leaving the agent to guess which listing tool fits a given need.

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 'with optional filters' hints at how to narrow results, but there is no explicit guidance on when to use this tool versus 'search_status_updates' or the other status-update siblings. No exclusions, prerequisites, or recommended contexts are provided.

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 never states whether the result is paginated, whether status filtering is optional, whether an empty list is returned for an epic with no stories, or what ordering to expect. 'List' implies a read, but nothing concrete is disclosed.

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

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

A single short sentence with no filler, and the key scoping constraint (epic) is front-loaded. It is efficient, though the extreme brevity is part of why other dimensions are thin.

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 filtered list with a fully documented two-parameter schema and no output schema, the description covers the essentials. It falls short of complete because it omits pagination behavior and any mention of the status filter that the schema exposes.

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 epic_id (UUID, required) and the status enum are already fully documented in the schema. The description only echoes the epic scoping and says nothing about the status filter, so baseline 3 applies.

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

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

States a specific verb (list) and resource (stories) scoped to a parent epic, so the agent knows exactly what it retrieves. It does not, however, distinguish itself from nearby siblings such as list_issues or get_story, so the purpose is clear but not sibling-differentiated.

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 'for a specific epic' implies the call context, but there is no explicit when-to-use guidance, no statement of when not to use it, and no mention of alternatives like list_issues or search_issues. The agent must infer the routing decision entirely on its own.

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. 'List' implies a read-only operation, but the description omits ordering, pagination/limit behavior, permission needs, and what a result set looks like, leaving significant behavioral gaps.

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

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

A single front-loaded sentence with no filler; the resource and its filterability are stated immediately. It is efficient, though deliberately terse rather than polished.

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 schema is rich (enums, defaults) and there is no output schema to explain, so the description need not document returns. Still, with zero annotations, a list tool arguably warrants a note on scope or ordering; what is present is adequate but thin.

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 each parameter; baseline 3 applies. The description's mention of 'type, tags, or related entities' loosely maps to the parameters but adds no syntax or semantics beyond them, and says 'tags' plural while the schema exposes a single 'tag'.

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 gives a clear verb ('List') and resource ('summaries') and enumerates the filterable dimensions. However, it does not distinguish this tool from sibling list/read tools such as search_summaries or get_summary, so an agent still needs schema inspection to route correctly.

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?

Stating that filters are optional implies the tool is for enumerating summaries, which is adequate minimum-viable guidance. But there is no explicit when-to-use clause and no contrast with the obvious alternative search_summaries, leaving the agent to infer the boundary.

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 does not state that this is a read-only operation, whether results are ranked or paginated, or how matches are determined (substring, full-text, semantic). 'Search' implies read-only by convention only.

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 zero filler; the action and scope come first and nothing is repeated.

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 two-parameter search with no output schema and fully documented params, the definition is minimally sufficient. It lacks any note on result shape or ranking, but the schema and absence of a return contract lower the bar.

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 keyword and limit are already fully documented with types and the default. The description adds no syntax, matching behavior, or result-count guidance beyond the schema, so baseline 3 applies.

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

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

States a specific verb (search) and resource (context entries) with a qualifier (by keyword) that separates it from get_context and list_context. It does not explicitly name those siblings, but an agent can infer the distinction.

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 says what the search is for ('find relevant conversations or knowledge') but never states when to prefer it over list_context, get_context, or search_summaries/search_issues. No prerequisites, no exclusions, no alternatives 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?

No annotations are present, so the description carries the full burden. It only says search by keyword; it doesn't disclose pagination behavior, result ordering, permissions, or what the response contains beyond the obvious. For a read operation this is a significant 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?

A single sentence with zero waste, front-loaded with the verb and resource. It is appropriately sized for the simplicity of the 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?

Given the low complexity and full schema coverage, the definition is minimally adequate for invocation, but it leaves gaps: no usage context relative to sibling tools and no indication of what a result looks like, which matters because there is no output schema.

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 keyword, limit, and project_id. The description adds no parameter meaning beyond what the schema provides. 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?

States a specific verb ('Search') and resource ('issues') with the search field ('by keyword'). It is clear what the tool does, but it does not differentiate from sibling list_issues or explain how this differs from other issue-retrieval 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?

No when-to-use guidance is provided. The description does not mention alternatives like list_issues or get_issue, nor does it state when a keyword search is preferable to browsing or fetching a single issue.

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 falls short. It does not disclose matching semantics (substring vs full-text, which fields are searched, case sensitivity), pagination behavior, or result ordering — all material for a search tool. The only behavioral signal is the implicit read-only nature of 'search'.

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

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

A single short sentence with no filler and the core action front-loaded. It is efficient, though at this length 'concise' shades into under-specified rather than well-trimmed.

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 read tool with no annotations and no output schema, the definition is minimally viable: the agent can call it correctly. It is incomplete in that nothing explains how matching works or what the results contain, which matters given there is no output schema to fall back on.

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 'keyword' and 'limit' documented inline including the default of 20, so the schema already does the heavy lifting and a baseline 3 applies. The description's 'by keyword' only restates the required parameter and adds no syntax, format, or constraint details 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 gives a clear verb+resource pair ('Search status updates') and adds the primary filter ('by keyword'), so an agent immediately knows what the tool does. However, it does nothing to separate itself from sibling search tools such as search_summaries, search_issues, or search_context, which share the identical 'search X by keyword' shape.

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_status_updates (browse all) or the other search_* tools. No prerequisites, no exclusions, no mention of what happens when the keyword matches nothing. The agent must infer the search-vs-list distinction entirely from the names.

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 repeats the schema's field description without disclosing search behavior such as case sensitivity, partial matching, result ordering, or pagination beyond the schema's limit parameter.

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 efficient sentence that front-loads the core action and resource. It avoids unnecessary words, though it could be slightly more informative without becoming verbose.

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 search tool with no annotations and no output schema, the description is incomplete. It does not explain what the search returns, whether results are ranked, or any side effects or constraints, leaving the agent with minimal context beyond the schema.

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 description does not add meaning beyond the schema. The keyword parameter is already fully documented in the schema, so the baseline score 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 states a specific verb (Search) and resource (summaries), and specifies the search fields (title or content). It distinguishes the tool from list_summaries, but does not explicitly distinguish it from other search_* siblings like search_issues or search_context.

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

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

There is no guidance on when to use this tool versus alternatives such as list_summaries or get_summary. The description only states what the tool does, leaving the agent to infer usage 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 behavioral burden for a mutating tool, and it discloses almost nothing. It does not say whether this is a partial merge or full replacement, whether omitted fields are preserved or cleared, whether permissions are required, or whether the change is reversible.

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 zero filler. It is appropriately sized for what it says, though the terseness reflects under-specification rather than efficient 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?

For a mutation tool with 5 parameters, no annotations, and no output schema, the description is far too thin. The critical question of whether only context_id is required and all other fields are optional partial updates is left to the schema alone, and no return or confirmation behavior is described.

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 is already documented in the schema (including the enum values for context_type and the UUID requirement for context_id). The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (update) and resource (context entry), which cleanly separates it from update_issue, update_summary, and update_project siblings. It does not, however, differentiate itself from other update-family tools beyond the resource name, and gives no sense of 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?

No guidance on when to use this versus create_context or delete_context, no prerequisites, and no mention of what a caller must already know (e.g. that the context_id must reference an existing entry). 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?

With no annotations, the description carries the full behavioral burden for a mutation tool. It does not disclose whether unspecified fields are preserved, required permissions, or reversibility, leaving the agent with only the bare implication that this mutates an epic.

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 it is under-specified rather than genuinely concise. It fails to earn its place by conveying any information beyond the tool name.

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 five-parameter mutation tool with no annotations and no output schema, the description should explain partial-update behavior, the required epic_id, and return semantics. It leaves these gaps unaddressed, making it inadequate 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 description coverage is 100%, so the schema already documents all five parameters including the enums for status and priority. The description adds no syntax, format, or semantic detail beyond what the schema provides, so the baseline of 3 applies.

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

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

The description gives a clear verb+resource ('Update epic information'), but it is essentially a restatement of the tool name and does not specify what aspects are updatable or how it differs from sibling update tools like update_issue or update_story. The schema lists fields, but the description itself is vague about 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?

No when-to-use guidance, prerequisites, or alternatives are provided. The agent receives no signal about when to prefer update_epic over create_epic, delete_epic, or other update_* tools, nor about partial-update semantics.

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, yet it only restates the name. It does not say whether this is a partial/patch update (fields omitted are preserved), whether it requires permissions, whether setting status to resolved/closed has side effects, or whether it is idempotent. For a 10-parameter mutation tool this is a substantial 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 single five-word sentence is maximally concise and front-loaded. But conciseness here shades into under-specification: there is no structure or second sentence to convey the update semantics the tool actually needs, so it is terse rather than 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?

Given a 10-parameter mutation tool, no annotations, and no output schema, the description is far too thin. It omits partial-update semantics, permission requirements, side effects of status transitions, and what the response contains – all of which an agent needs to call this 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 100%, so all ten parameters (including the required issue_id and the four enum fields) are documented in the schema itself. The description adds no semantics beyond that, so the baseline of 3 is appropriate; it neither compensates for nor extends the schema.

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

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

The description names a specific verb ('Update') and resource ('issue'), so the basic operation is unambiguous. However, it offers no differentiation from siblings like update_epic, update_story, or update_project, and gives no hint that this is a partial update of arbitrary fields. An agent knows what it does but not how it differs from the other update_* 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?

There is no when-to-use guidance, no mention of prerequisites, and no reference to any alternative tool (e.g., create_issue vs. update_issue, or closing an issue via status). The agent must infer entirely from the tool name that this modifies an existing issue rather than creating 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: not whether fields are partially or fully overwritten, whether omitting a field clears it, what permissions are required, or whether the change is reversible. Exercise caution: this is a mutation tool with zero safety 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?

The description is a single short, front-loaded sentence with no padding. However, its brevity reflects under-specification rather than efficient communication of the necessary information.

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 four-parameter mutation tool with no annotations and no output schema, the description is wholly inadequate. It leaves unanswered everything an agent needs: update semantics, permission requirements, and the effect on unspecified fields.

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 each of the four parameters (name, status with an enum, project_id, description) is documented in the schema itself. The description adds no additional parameter meaning, 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?

"Update project information" is essentially a restatement of the tool name update_project, with only the vague word "information" added. It gives no indication of which fields are mutable or how this differs from the many sibling update_* tools. This is tautological rather than clarifying.

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 alternatives such as update_issue or update_epic. The agent must infer entirely from the name that this tool targets projects rather than any other resource.

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 bears the full behavioral burden. It does not disclose whether this is a partial/patch update or a full replace (leaving unspecified optional fields ambiguous), what permissions are required, or whether the change is reversible. For a mutation tool with zero annotation coverage, this is a significant 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?

A single short sentence with no filler, so there is nothing wasteful. But it is under-specified rather than genuinely concise, trading away useful context for brevity.

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 mutation tool with no annotations and no output schema, the description is too thin: it omits partial-vs-full update semantics, permission/auth requirements, and response behavior. An agent has to infer all of this.

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 all five parameters are already documented in the schema (tags, title, content, status_type, status_update_id). The description adds no syntax, format, or interaction detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (update) and resource (status update), and the object 'existing' clarifies it targets an already-created entity. However, it does nothing to distinguish this from the many other update_* siblings (update_issue, update_project, update_summary) or to indicate which fields are mutable. Clear but no 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?

There is no when-to-use guidance, no mention of prerequisites (e.g., that status_update_id must reference an existing record), and no reference to alternatives such as create_status_update or delete_status_update. Usage is only implied by 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 must carry the full behavioral burden. The word "Update" implies a state-changing operation, but the description does not disclose partial-update semantics, required permissions, side effects, idempotency, or failure behavior. This leaves major behavioral gaps 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?

The description is only four words, which is extremely terse and under-specified for a tool with seven parameters. While it is front-loaded and free of filler, it provides too little information to be useful to an agent.

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 mutation tool with no annotations and no output schema, the description omits key context such as update semantics, return values, and error behavior. Although the schema fully documents parameters, the lack of behavioral detail leaves the definition contextually incomplete.

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 seven parameters, including the required story_id and the two enum fields. The description adds no additional parameter meaning or syntax beyond what the schema provides, making the baseline score of 3 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 states a generic verb and resource ("Update story information"), making the basic action clear. However, it does not specify what story information can be updated or distinguish this tool from sibling update tools like update_issue or update_epic. It is minimally viable but vague about 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?

No guidance is provided on when to use this tool versus alternatives such as create_story, delete_story, or get_story. There is also no mention of prerequisites or whether it performs a partial or full update. The agent must infer all usage conditions.

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 confirms a mutation on an existing entity, but says nothing about whether this is a partial or full replacement, whether omitted fields are preserved or cleared, whether it requires ownership/permissions, or whether the operation is reversible.

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 the brevity comes from under-specification rather than efficient communication. There is no filler, yet nothing earns its place beyond restating the tool name.

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?

A mutation tool with six parameters, a nested metadata object, an enum, no output schema, and no annotations needs substantially more description than five words. An agent cannot determine update semantics, required permissions, or what happens to unspecified fields from this definition.

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 all six parameters including the required summary_id and the enum-constrained summary_type are already documented in the schema. The description adds no format, constraint, or interaction detail, so the baseline 3 for fully covered schemas applies.

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

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

The description states a clear verb ('Update') and resource ('summary'), so the basic operation is identifiable. However, it offers no scope, no distinction from siblings like update_issue, update_project, or update_status_update, and no indication of what fields are mutable. It is the minimum viable 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 when-to-use guidance beyond the word 'existing', and no mention of alternatives (e.g. create_summary for new records, or delete_summary). The agent must infer entirely from the name which sibling tool applies to its situation.

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