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

Given no annotations, the description carries the burden of behavioral disclosure. It only states the action 'Add' without any behavioral details such as whether the operation is idempotent, overwrites existing entries, or has specific 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?

The description is a single, compact sentence that conveys the core purpose without any unnecessary words. It is appropriately front-loaded and easy to parse.

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

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

The description is extremely sparse. For a write operation with no annotations or output schema, it fails to provide context about expected behavior, valid knowledge_type values, or how this relates to sibling tools. The schema covers parameters but not the broader usage context.

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

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

The input schema has descriptions for all 5 parameters (100% coverage), so the schema already provides the necessary parameter semantics. The description does not add any parameter-specific meaning beyond what the schema offers.

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

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

The description clearly identifies the action (Add), the resource (knowledge entry), and the context (to the project). It distinguishes itself from siblings like get_project_knowledge and other 'add' tools by specifying the knowledge entry resource.

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, or any prerequisites or exclusions. The description simply states what it does, leaving the agent to infer appropriate usage.

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

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

Annotations are absent, so the description bears the full burden of behavioral disclosure. It explains the dependency direction but does not mention edge cases such as existing dependency behavior, cycle prevention, or error conditions for invalid task IDs.

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

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

The description is a single, compact sentence with a clarifying parenthetical. It is front-loaded with the action and contains no unnecessary words.

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

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

For a simple two-parameter tool, the description covers the core functionality. However, it lacks contextual information about when to use it, potential validation issues, and interaction with existing dependencies. Given the presence of sibling tools like remove_task_dependency, more usage context would improve completeness.

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

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

The input schema already provides fully descriptive parameter names and descriptions for both blocked_task_id and blocking_task_id, covering 100% of parameters. The description's parenthetical reinforces the direction but adds no additional parameter-level details.

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

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

The description clearly states the action ('Add'), the resource ('blocking dependency between tasks'), and defines the directional semantics ('blocked_task waits for blocking_task to complete'). It distinguishes from the sibling tool remove_task_dependency by describing the creation side.

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 like remove_task_dependency or update_task. The description defines the operation but lacks context about prerequisites, conflict handling, or use cases.

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 transparency burden. It discloses two behavioral traits: plan notes auto-resolve previous plans and priority defaults for plan/information types, which are non-obvious. However, it does not specify whether the note is appended or if there are other side effects, so it's not fully transparent.

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

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

Two sentences, front-loaded with the main action. No wasted words; each sentence adds meaningful 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 simple tool, the description covers the core purpose and two important behavioral details. It lacks mention of return value or explicit statement that a new note is created (though implied), but schema covers parameters, so context is largely 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?

Schema coverage is 100%, with descriptions for all four parameters. The description adds some behavioral context (auto-resolve) but mostly repeats schema info like priority defaults, so it provides minimal additional parameter semantics.

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

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

The description clearly states the action ('Add a working note') and the resource ('to a task'), and enumerates valid note types, distinguishing it from retrieval (get_task_notes) and resolution (resolve_working_note) siblings.

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

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

The description implies when to use (adding a note to a task) but does not explicitly contrast with alternatives like resolve_working_note or escalate_working_note. It lacks explicit when-not or alternative guidance, making it adequate but not distinguished.

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 only says 'claim a task to work on it', revealing nothing about side effects (e.g., locking the task, changing its assignee, or whether an unclaimed task is required). This is a minimal statement with no behavioral detail.

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

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

The description is a single concise sentence, front-loaded with the action and object, containing no fluff. It is efficiently structured, though it would benefit from a short additional sentence on behavior or usage context, but as a standalone description it is appropriately compact.

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 simplicity of one parameter and no output schema, the description still lacks essential context: it does not mention what happens after claiming, whether it returns anything, what the preconditions are, or how it fits with sibling tools like get_next_task or complete_task. For a mutation tool, this is 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?

The schema description covers 100% of the parameter (task_id with 'ID of the task to claim'), and the tool description adds no additional meaning. Per the baseline for high schema coverage, a score of 3 is appropriate since the schema does the heavy lifting.

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

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

The description uses a specific verb 'claim' and resource 'task', clearly indicating a distinct action among siblings like get_next_task or update_task. It conveys that the tool is for taking ownership of a task to work on it, though it could be more explicit about what 'claim' entails.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any context on prerequisites or typical workflow (e.g., after get_next_task). It merely states the action without any contextual placement.

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

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

With no annotations, the description carries full burden. It discloses a non-obvious behavior: triggering validation questions based on project knowledge, and instructs the agent to answer them by re-calling the tool. This goes beyond a simple 'complete' and adds useful behavioral context, though it doesn't mention reversibility or permissions.

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

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

The description is two sentences, front-loaded with the main action, and every sentence provides necessary information. No wasted words.

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

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

For a tool with a validation loop, the description covers the flow sufficiently: complete triggers questions, and you answer by re-invoking with the message parameter. It doesn't explicitly state the final outcome after answering all questions, but the behavior is clear enough given the schema and sibling context.

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

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

Schema coverage is 100%, so baseline is 3. The description adds extra meaning beyond the schema by explaining that 'message' is used to answer validation questions and that 'task_id' is optional during validation. This clarifies when and how to use each parameter, adding value.

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

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

The description clearly states 'Mark a task as completed', a specific verb+resource action. It distinguishes from siblings like update_task by emphasizing the completion and validation trigger. The added validation flow details remove ambiguity.

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

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

It provides clear context: use to complete a task, and if validation questions are returned, call again with the answer in the message parameter. It doesn't explicitly name alternatives or exclusions, but the process is well-defined.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It merely states the action without mentioning side effects, permissions, reversibility, or any other behavioral traits. This is a critical gap for a mutation tool.

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

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

The description is very concise, but it is under-specified rather than efficiently informative. It is a single short sentence that could benefit from additional context, making it acceptable but not exemplary.

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 create operation with no output schema and no annotations, the description lacks critical context such as return value, side effects, or when it is appropriate to invoke. It is minimally complete but leaves significant gaps.

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

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

The input schema describes all three parameters with 100% coverage, so the schema does the heavy lifting. The description adds no additional parameter meaning beyond what the schema already provides, 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?

The description 'Create a new epic' clearly identifies the action (create) and the resource (epic). It distinguishes from siblings like update_epic and create_task by specifying the resource type, but lacks any additional scope or context that would elevate it to 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 usage guidance is provided. The description does not indicate when to use this tool versus alternatives like create_task or update_epic, nor does it mention any prerequisites or context. This provides no help to an agent deciding between 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 of behavioral disclosure. It only states a write operation without mentioning side effects, validations, required parent context, or response behavior. This is a significant gap for a creation 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, direct sentence with no fluff. It is appropriately concise for a simple creation tool, though it sacrifices necessary 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?

The description is incomplete for a tool with 5 parameters and no output schema. It omits essential context such as the requirement to provide either a project_id or epic_id, return value expectations, and how this task fits into the broader workflow (e.g., epics, projects).

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 descriptions cover 100% of parameters, so the baseline is 3. The description adds no extra parameter semantics beyond what the schema already provides. It does not explain relationships between parameters (e.g., project_id required if epic_id absent).

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

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

The description 'Create a new task' clearly identifies the verb and resource, distinguishing it from siblings like create_epic. However, it is extremely minimal and adds no detail beyond the tool's name, so it does not fully leverage the opportunity to specify scope or 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?

No guidance is provided on when to use this tool versus alternatives such as get_next_task or create_epic. The description does not mention prerequisites like needing a project_id or epic_id, which are critical for correct usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Delete a shared context item,' which implies a destructive action but does not state whether deletion is permanent, idempotent, or scoped to a project. It also does not mention permissions or what happens if the item does not exist. This significant gap makes the tool's behavior opaque.

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

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

The description is a single concise sentence with no wasted words. It is front-loaded with the verb and resource, making it easy to scan. However, it is so terse that it borders on under-specification, though it does not contain any 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?

The tool has no annotations, no output schema, and a minimal description. For a deletion tool, the agent needs to know whether the action is destructive, reversible, or scoped to a project. The description provides none of this context, making it incomplete for the complexity of the operation.

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

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

The input schema already provides complete descriptions for all three parameters (key, category, project_id), covering 100% of the parameters. The description adds no extra meaning beyond what the schema offers, 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 uses a clear verb ('Delete') and a specific resource ('shared context item'), making the tool's purpose immediately obvious. It distinguishes from sibling tools like get_shared_context and set_shared_context through the verb, but does not explicitly differentiate itself, so it misses a top score.

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 exclusions, prerequisites, or conditions are mentioned. The usage is only implied by the tool name and the presence of sibling tools, which is insufficient for an agent to decide when to invoke this tool confidently.

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 disclose side effects such as whether the original note is deleted, modified, or left unchanged, nor does it mention permissions or other behavioral traits.

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

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

The description is a single concise sentence with no filler or redundant information. It directly states the core action and outcome, making it highly concise and well-structured.

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

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

Given the lack of annotations and output schema, the description is too minimal. It does not explain how task_id and note_id relate, what happens to the original note, or any expected return values. This leaves significant gaps for a mutation tool.

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

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

All three parameters have explicit descriptions in the schema (note_id, task_id, optional epic_id), achieving 100% schema description coverage. The tool description adds no additional parameter nuance, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb 'escalate' and clearly identifies the resource ('working note') and outcome ('new task'). This distinguishes it from sibling tools like resolve_working_note or create_task, which have different actions or inputs.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or scenarios where a different tool would be preferred.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic read operation and does not mention return format, pagination behavior, default limits, or the fact that project_id can default to the current claimed task's project. This is a significant gap for safe and correct invocation.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It earns its place by clearly naming the action and target, making it maximally concise.

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

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

Given the tool has no annotations, no output schema, and four optional parameters, the description is too sparse to provide complete context. It doesn't explain what an activity event consists of, how the optional parameters interact, or what happens when no filter is provided. This leaves the agent under-informed.

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 input schema already documents all four parameters with descriptions. The tool description adds no additional meaning beyond what the schema provides, meeting the baseline of 3.

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

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

The description clearly states the tool retrieves activity events for a project or task, using a specific verb and resource. It doesn't explicitly differentiate from sibling tools like post_activity, but the read-oriented wording makes the purpose obvious.

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

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

The description implies when to use this tool—whenever recent activity events for a project or task are needed. However, it provides no explicit guidance on alternatives, exclusions, or when to prefer another tool such as get_task_details or get_task_notes.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. 'Get' clearly indicates a read-only operation, and 'with all tasks' explains the output scope. However, it does not disclose potential error behavior, auth requirements, or whether tasks are returned in a nested structure, leaving some transparency 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?

The description is a single, front-loaded sentence that conveys the action, resource, and scope without any filler. Every word contributes meaning, making it highly concise and well-structured.

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

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

There is no output schema, so the description should clarify the return structure, but 'epic details' is vague and 'all tasks' does not specify whether tasks are full objects, IDs, or just summaries. This leaves a significant gap for an agent trying to predict the tool's output.

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

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

The schema already fully describes the only parameter, epic_id, with 100% coverage. The description does not add extra meaning about the parameter's format, source, or relationship to other entities, so it adds no value beyond the schema, meeting the baseline of 3.

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

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

The description uses a specific verb 'Get' with a clear resource ('epic details') and scopes the output with 'with all tasks', making it distinct from sibling tools like list_epics (which lists epics) and get_task_details (which retrieves a single task).

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

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

The description gives no explicit guidance on when to choose this tool over alternatives such as list_epics or get_task_details, and it does not mention any exclusions or prerequisites. The only implied hint is that it returns tasks along with epic details, but this is not stated as a recommendation.

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 full burden. It does not disclose whether the task is removed from the queue (destructive vs read-only), what happens if the queue is empty, or the return format. The word 'get' is ambiguous between a read and a pop.

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, clear sentence that conveys the core functionality without any wasted words or redundant details.

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

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

For a tool with no output schema and no annotations, the description leaves critical unknowns: return shape, behavior on empty queue, and whether the operation mutates state. Simple but incomplete for an agent to use 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?

The input schema fully describes project_id with 100% coverage, so the baseline is 3. The description adds no additional parameter semantics beyond what the schema already states.

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

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

The description clearly states the tool gets the next task from a queue, with ordering based on priority and dependencies. It distinguishes itself from siblings like claim_task (which implies ownership) and get_task_details (which fetches a specific task), though it does not explicitly name alternatives.

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

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

No guidance is given on when to use this tool versus alternatives such as claim_task or list_plan_tasks. The context is only implied by the description, not explicit.

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

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

No annotations are provided, so the description carries the burden. The verb 'Fetch' implies a read-only operation, and the description names the data source and content. However, it does not disclose potential authentication needs, rate limits, or any limitations of the overview/manifest data, which is acceptable but not exhaustive.

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 that clearly states the action and target without any filler. Every word contributes meaning, and it does not repeat schema details.

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 and no annotations, the description should clarify what the tool returns. It mentions 'overview, manifest, and epic metadata' but leaves the structure and granularity vague. For a simple retrieval tool with one parameter and a clear high-level purpose, this is adequate but not fully complete.

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

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

Schema description coverage is 100% for the only parameter, project_id, with a clear explanation of its format and relationship to KiraHub. The tool description adds no additional parameter semantics, but since the schema already documents the parameter well, 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 uses a specific verb ('Fetch') and a clear resource ('PlanCreator wiki') with a well-defined scope ('overview, manifest, and epic metadata'). This clearly separates it from sibling tools like get_epic or list_epics, which focus on individual epics or lists.

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

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

The description provides no guidance on when to use this tool instead of alternatives. It does not mention exclusions, prerequisites, or contrast with sibling tools such as get_epic, get_project_knowledge, or list_plan_tasks, leaving the agent to infer the appropriate use case.

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 discloses that the tool returns 'full markdown content and metadata' which describes the output type, but it does not mention read-only semantics, potential errors, authentication requirements, or return structure. It's adequate but not rich.

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, focused sentence that front-loads the action and resource. No unnecessary words or repetition. It earns its place entirely.

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 retrieval tool with two parameters and no output schema, the description covers the essentials: what is returned (full markdown content and metadata). It lacks a detailed breakdown of what 'metadata' includes, but given the tool's simplicity, this is sufficient for selection and invocation.

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

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

Schema description coverage is 100% with clear descriptions for task_id ('Task identifier or title (case-insensitive)') and project_id ('Project identifier to load tasks for'). The tool description adds no parameter semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses the specific verb 'Retrieve' with a clear resource: 'full markdown content and metadata for a specific plan task from the PlanCreator wiki'. This clearly distinguishes it from sibling tools like 'get_task_details' or 'list_plan_tasks' by emphasizing the full content retrieval.

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

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

The description implies usage when a user needs the full markdown body and metadata of a task, but it does not explicitly state when to use this tool over alternatives or provide exclusion criteria. No sibling tools are mentioned or contrasted.

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. The verb 'Search' clearly indicates a read-only operation, which is a useful safety signal. However, it doesn't disclose what the search returns (e.g., snippets, full documents), any ordering/filtering semantics, or potential limitations.

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

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

The description is a single sentence that front-loads the key action and resource. It is appropriately sized with zero waste—every word contributes to understanding the tool's purpose.

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 three well-documented parameters and no output schema, the description provides sufficient context by explaining what the knowledge base contains. The lack of output guidance is mitigated by the intuitive nature of a search action, though the description could mention typical use cases.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning to the parameters beyond what the schema already states; it doesn't elaborate on how 'type' or 'search' interact or the format of project_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?

The description uses the specific verb 'Search' and clearly identifies the resource as 'project knowledge base', with a parenthetical that details content types (architecture, best practices, specs). This clearly distinguishes it from sibling tools like get_task_details and add_project_knowledge.

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

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

The description implies usage for finding project knowledge, but provides no explicit when-to-use vs alternatives or exclusions. For example, it doesn't mention that add_project_knowledge is for adding while this is for searching, or when search_plan_tasks might be more appropriate.

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

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

Annotations are not provided, so the description carries the full burden. It does not mention that this is a read-only operation, permissions requirements, or return behavior. The description only indicates the resource type, leaving behavior mostly implicit.

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

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

The description is a single, front-loaded sentence that wastes no words. It conveys the core purpose and lists relevant categories, making it efficient and easily scannable.

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

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

For a getter tool with no output schema and multiple optional filters, the description should explain what is returned and how the optional key/category/project_id affect the result. It does neither, leaving the agent to infer the return format and filtering behavior.

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

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

The input schema already describes all three parameters with 100% coverage. The description lists categories that match the enum, but this duplicates schema information and adds no additional meaning about how parameters combine or what formats are expected.

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

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

The description clearly states it retrieves shared context for a project and lists the main categories. It is a specific verb+resource, but it does not distinguish itself from the sibling tool get_project_knowledge, which might serve a similar retrieval purpose.

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

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

There is no guidance on when to use this tool versus alternatives such as set_shared_context or get_project_knowledge. The description only implies usage by naming the resource but provides no context or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds value by specifying that the details include dependencies and notes, giving some sense of the return content. However, it does not disclose whether the operation is read-only (implied by 'get'), any auth requirements, rate limits, or what other fields might be present. This is a minimal but not fully transparent disclosure.

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

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

The description is a single, concise sentence that is front-loaded with the action ('Get') and resource ('task'). It communicates the key additional details ('dependencies and notes') without any waste, making it optimally sized.

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

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

The tool is simple (one parameter, no output schema), so the description carries responsibility for explaining return values. It mentions dependencies and notes but leaves 'detailed information' vague, not clarifying what other fields are included or any limitations. This is adequate for a basic get operation but not fully complete given the absence of an 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%: the single parameter 'task_id' is described as 'Task ID'. The description does not add any additional meaning beyond the schema, but since the schema fully documents the parameter, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Get detailed information about a task including dependencies and notes'. The verb 'Get' is specific, the resource is 'task', and the scope is 'detailed information' with explicit mention of dependencies and notes. This effectively distinguishes it from sibling tools like 'get_task_notes' (which focuses only on notes) and 'get_plan_task_details' (which targets plan tasks).

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

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

The description implies usage: when you need detailed task information with dependencies and notes. However, it provides no explicit guidance on when to use this tool versus alternatives like get_task_notes or get_plan_task_details. No exclusions or alternative suggestions are given, so the usage context is only implied.

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

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

No annotations are provided, so the description must carry the burden. 'Get' implies a read-only operation, but the description does not disclose potential behaviors such as whether resolved notes are included, ordering, or pagination. It is minimally transparent but not misleading.

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

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

The description is a single concise sentence with no unnecessary words. It is front-loaded with the action and resource, making it quickly parsable.

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 getter, the description is nearly complete. It does not explain the return format or note statuses, which could be ambiguous given sibling tools for resolving/escalating notes, but the low complexity keeps the gap small. An output schema is absent, so a bit more detail would help, but it is still sufficient for selection and invocation.

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

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

Schema coverage is 100% (task_id is described as 'Task ID'), so the baseline is 3. The description does not add any extra meaning beyond the schema parameter. It neither enriches nor repeats the parameter explanation, which is acceptable for a single obvious parameter.

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

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

The description 'Get all working notes for a task' uses a specific verb ('get'), a specific resource ('working notes'), and a scope ('for a task'). It clearly distinguishes from sibling tools like add_working_note, resolve_working_note, and escalate_working_note by being the retrieval operation.

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

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

The description implies usage: one would call this when they need all working notes for a task. However, it provides no explicit context, exclusions, or alternatives. The usage is evident from the purpose, but there is no guidance on when not to use it or how it differs from get_task_details.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic action and does not mention whether archived epics are included, how results are ordered, whether pagination applies, or any permissions required. The behavior is not misleading but is under-specified.

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

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

The description is a single concise sentence, 'List all epics for a project', with no redundant wording. Every word earns its place, and the structure is front-loaded with the verb and resource.

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, the description covers the core purpose and the schema covers the parameter. However, it lacks context about the return format, whether all epics means including archived/closed ones, and any ordering or filtering defaults. Given the absence of annotations and output schema, this is a minimal-but-not-complete description.

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

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

The schema fully documents the single parameter project_id with a clear description, so the tool description does not need to add parameter details. The description adds no extra meaning beyond the schema, which is acceptable given 100% schema coverage.

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

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

The description clearly states the action (List), the resource (epics), and the scope (for a project). It distinguishes from sibling tools like get_epic (singular) and create_epic by indicating a bulk list operation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_epic or list_plan_tasks. It does not mention filtering, pagination, or any exclusions, leaving the agent to infer usage solely from the name.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It indicates a read operation ('List') and mentions metadata, but it does not explicitly state that it is read-only, nor does it discuss pagination, error behavior, or any side effects. This adds some context beyond the schema but is not fully transparent.

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

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

The description is a single sentence that is front-loaded with the action and resource. It contains no filler or redundant content, earning its place with the purpose clause. It is appropriately concise for a simple list operation.

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

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

For a tool with only one parameter and no output schema, the description conveys the main purpose and a general idea of the result ('tasks ... with metadata'). However, it lacks details about the exact metadata fields returned and does not explicitly guide the agent on when to select this tool over similar siblings, leaving some gaps.

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

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

The schema covers 100% of the parameter (project_id) with a clear description, so the baseline is 3. The tool description does not add any additional meaning about the parameter format, valid values, or constraints beyond what the schema already provides.

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

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

The description uses the specific verb 'List' with a clear resource ('tasks from the PlanCreator wiki') and a purpose ('to understand available plan steps'). This distinguishes it from sibling tools like get_next_task (single task) and list_epics (epics), making the tool's function unambiguous.

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

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

The phrase 'to understand available plan steps' implies a use case (gaining an overview of plan steps), providing clear context. However, it does not explicitly state when not to use it or name alternatives like search_plan_tasks or get_task_details, so it lacks exclusions.

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 discloses a key behavior: project_id and task_id are auto-filled from the currently claimed task if omitted. This is useful contextual information. However, it does not mention what happens if no task is claimed, or describe success/failure responses, but for a logging tool the core behavior is sufficiently transparent.

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

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

The description is longer than most but every sentence and bullet earns its place. It starts with a clear summary, then uses a well-organized bullet list for event type triggers, and concludes with the auto-fill behavior. The structure is highly scannable for an AI 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?

Given the tool's moderate complexity, the description is complete. It covers the purpose, when to call, what events to use, and default parameter behavior. No output schema exists, so return values are not required. The description fully equips the agent to select and invoke the tool correctly.

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

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

Schema coverage is 100% with each parameter described, but the description adds significant semantic value by mapping each event_type to concrete scenarios (e.g., 'Post progress after completing each significant milestone'). It also explains the auto-fill behavior for project_id and task_id, which is not fully captured in 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 clearly states the tool's purpose: 'Post an activity event to track what the agent is doing.' It uses a specific verb ('post') and resource ('activity event'), and the extensive list of event types distinguishes it from the sibling 'get_activity' tool, which reads activity.

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

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

The description provides explicit, proactive usage instructions: 'You MUST call this proactively throughout your work — do not wait to be asked.' It then details specific triggers for each event type (progress, file_created, decision, etc.), giving the agent clear when-to-use guidance that goes beyond generic alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action (remove a blocking dependency) but does not disclose potential side effects (e.g., whether it fails if the dependency does not exist, whether removal is reversible, or if it affects task statuses). This is insufficient 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 a single, focused sentence with no redundant words. It communicates the essential operation efficiently and earns its place without any 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?

Given the simple nature of the tool (two well-documented parameters, no nested objects, no output schema), the description is minimally complete. However, it lacks context around edge cases, error handling, or idempotency, which would be valuable for a mutation tool without annotations. It covers the basics but leaves gaps.

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

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

The input schema provides full descriptions for both required parameters ('blocked_task_id' and 'blocking_task_id'), achieving 100% coverage. The description adds no extra semantic value beyond what the schema already states, 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 uses a specific verb ('Remove') with a clear resource ('blocking dependency') and scope ('between tasks'). It directly distinguishes the tool from its sibling 'add_task_dependency' and other task-related tools, making its purpose unambiguous.

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

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

The description implies when to use the tool (when you need to remove a blocking dependency) but provides no explicit exclusions or alternatives. It is clear enough for a straightforward operation, but it does not guide the agent on when not to use it or how it contrasts with related tools like 'add_task_dependency'.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only states the action (mark resolved) but does not reveal side effects: whether it is reversible, whether it deletes or hides the note, whether it requires certain permissions, or if it affects the associated task status. This is significant 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 a single concise sentence with no wasted words. However, it is slightly under-specified, missing useful context that could be added without breaking conciseness. Overall, it is efficient and front-loaded.

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

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

The tool has low complexity (2 simple params, no output schema), so a minimal description might suffice. Yet it lacks any mention of post-conditions, error cases, or how resolution affects other tools like get_task_notes. Given the existence of sibling notes-related tools, a bit more context would improve completeness.

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

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

The schema describes both parameters (task_id, note_id) with simple descriptions at 100% coverage. The tool description adds no additional meaning, such as the relationship between task and note or the expected format. Baseline 3 applies because schema already covers the parameters adequately.

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

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

The description 'Mark a working note as resolved' uses a specific verb and resource, clearly identifying the action and target. It distinguishes from siblings like add_working_note (creation) and escalate_working_note (escalation), making the purpose unambiguous.

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

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

The description implies usage: resolve a note when its content is no longer relevant or issue is addressed. However, it provides no explicit guidance on when to choose this over alternatives like escalate_working_note or update_task. It lacks any exclusions or alternative recommendations.

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 behavioral disclosure burden. It reveals that the tool searches multiple fields and returns matching tasks, but does not mention output format, pagination, ordering, or any access limitations. For a read-only search operation, this is partially transparent but lacking in return behavior details.

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, focused sentence that front-loads the action (Search), resource (plan tasks), and key criteria (by title, description, tags, or content) without any fluff or repetition. Every word contributes meaning.

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

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

Given the tool's simplicity (2 params, no nested objects, no output schema) and the presence of sibling tools for detailed views, the description covers the essential purpose and search fields. It lacks an explicit statement about the return payload, but for a context-finding tool this is a minor gap, making it mostly complete.

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

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

While schema descriptions already cover both parameters, the tool description adds value by explicitly enumerating the searchable fields (title, description, tags, content) rather than the generic 'metadata or content' in the schema. This gives the agent richer understanding of what the query parameter matches against.

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

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

The description clearly states the tool searches plan tasks within PlanCreator using specific searchable fields (title, description, tags, content). This distinguishes it from sibling tools like list_plan_tasks (which likely lists all tasks) and get_task_details (which retrieves specific task details).

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

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

The description implies use when needing to find tasks by query terms across metadata/content, providing clear context for when this tool is appropriate. It does not explicitly mention alternatives or exclusion cases, but the search-vs-list distinction is inferable from the phrasing.

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 full responsibility. It discloses the write behavior and intended visibility ('so other agents can see your work') and gives value examples, but does not state whether setting an existing key overwrites or errors, nor any permission requirements. This is a notable gap for a mutation tool.

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

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

The description is well-structured with a brief introductory sentence followed by a scannable bullet list. Each bullet earns its place, and the length is appropriate for the operational guidance it provides, avoiding fluff.

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

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

The description covers the 'why', 'when', and 'what' with examples, and mentions optional project_id behavior. It lacks detail on return values or idempotency, but given the tool's coordination purpose and the schema's richness, it is sufficiently complete for an agent to select and invoke the tool 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?

Input schema already covers 100% of parameters with descriptions. The description adds meaningful semantics beyond the schema by providing a concrete value example ('{ definition: "interface User {...}", location: "src/types.ts" }') and instructing to 'include rationale' for decisions, which enriches the value parameter meaning.

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 opens with 'Set a shared context item so other agents can see your work', which is a specific verb+resource statement. It clearly distinguishes this from sibling tools like get_shared_context and delete_shared_context by focusing on the 'set' action and enumerating concrete categories.

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 an explicit 'You SHOULD call this when:' list with concrete scenarios mapped to categories (e.g., 'You create or modify a shared interface/type → category: contracts'). It also explains the coordinating benefit, making it clear when this tool should be used over alternatives.

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

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

With no annotations provided, the description carries the full burden and discloses important behaviors: it uses the current task automatically, auto-resolves previous plan notes, and is intended for post-plan-mode use. This goes beyond the schema and provides useful operational 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?

Three concise sentences, front-loaded with the core purpose. Each sentence adds meaningful information without redundancy, making it easy to parse quickly.

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

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

The tool is simple with two parameters and no output schema. The description fully covers the essential behavioral context (auto-context, auto-resolution, invocation timing) and clearly situates it among the 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 description coverage is 100% and both parameters are well-described in the schema. The description adds little beyond what the schema already states about task_id being an optional override. Thus the baseline of 3 is appropriate.

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

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

The description clearly states the action (sync), the target resource (an implementation plan to the currently claimed task as a working note), and adds distinctive details like automatic context use and auto-resolution of previous notes. This differentiates it from sibling tools like add_working_note and resolve_working_note.

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 explicit timing guidance ('Call this after exiting plan mode') and emphasizes automatic context use, which implies when to use it. It does not explicitly name alternatives or when-not scenarios, but the specialization is clear from the 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, the description carries the full burden of behavioral disclosure. It only implies a mutation operation ('update') but does not mention whether partial updates are allowed, the effect on existing fields, error conditions, or 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?

The description is extremely concise with zero filler, and the core action is front-loaded. While it is efficient, it is so minimal that it provides little beyond a tautological expansion of the tool name, though it is not misleading.

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

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

The description lacks essential context for an update operation: no return value specification, no note on partial updates, no error handling, and no usage scenarios. Given no annotations or output schema, the description does not sufficiently compensate for the missing information.

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

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

The input schema has 100% description coverage for all four parameters, so the baseline is 3. The description itself adds no parameter-level meaning, but the schema already defines each field (name, status, epic_id, description) clearly.

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

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

The description clearly identifies the action (update) and resource (epic), which distinguishes it from create_epic or get_epic. However, 'details' is generic and doesn't specify the update scope beyond the resource, so it's not fully specific.

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 alternative tools like update_task, or on situations where updating an epic is appropriate. The description gives no prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Update task details' and does not explain whether it performs a partial or full update, whether status transitions are validated, what happens to omitted fields, or what the response contains.

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

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

The description is a single, front-loaded sentence with no filler. It is concise, but it is also too terse to add meaningful information beyond the tool name, which is why it does not earn a 5.

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 no output schema, no annotations, and multiple related sibling tools, the description is insufficiently complete. It does not mention update semantics, effects on other task operations, whether task_id must be a valid existing task, or how partial updates are handled.

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

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

The schema has 100% parameter description coverage, so the tool description need not restate parameter meanings. The schema's descriptions are minimal but understandable ('New tags', 'New title', etc.), and the enum for status is self-explanatory, so the baseline of 3 is appropriate.

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

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

The description 'Update task details' clearly identifies the operation (update) and the target resource (task), which distinguishes it from creation, completion, and claim tools. However, it is somewhat generic in not specifying what 'details' means without the schema.

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

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

The description provides no guidance on when to use this tool versus alternatives like complete_task, claim_task, or update_epic. There is no mention of prerequisites, conditions, or situations where a different tool would be more appropriate.

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