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

With no annotations provided, the description must fully disclose behavioral traits. It only states the tool adds a blocker but does not describe side effects, authorization needs, or what happens after creation (e.g., impact on goal status). This lack of detail leaves the agent uninformed about consequences.

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

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

The description is a single, well-structured sentence that front-loads the key information. It is concise and directly states the usage context, though it could be slightly expanded with parameter guidance without losing 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?

Given 4 parameters with no schema descriptions, no output schema, and no annotations, the description is insufficient. It only covers 'when to use' but omits input details, output expectations, and behavioral nuances, making it inadequate for an AI agent to invoke correctly.

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

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

The input schema has 4 parameters (sessionId, description, status, resolution) with 0% description coverage. The tool description adds no explanation of these parameters, leaving the agent to infer their meaning solely from names and schema constraints. For example, 'sessionId' could be ambiguous.

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 explicitly states the tool's purpose: 'Call this when progress is blocked by missing input, failing dependencies, permissions, unclear requirements, or external failures.' This clearly identifies the action (adding a blocker) and the specific scenarios, distinguishing it from siblings like taskguard_update_blocker or taskguard_check_scope_drift.

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

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

The description gives clear examples of when to use the tool (blocked by missing input, etc.), providing good context. However, it does not mention when not to use it or suggest alternatives like taskguard_update_blocker for updating an existing blocker.

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 must disclose behavior. It only mentions 'makes progress auditable,' which is a purpose statement. No information about side effects, idempotency, permissions, or error conditions is provided.

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, no fluff. Every word contributes to the core message. Ideal length for an agent to quickly grasp 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?

Given no output schema and no annotations, the description is insufficient. It omits how sessionId relates to checkpoints, what happens if the session doesn't exist, and the semantics of optional fields (dueHint, description). The agent needs more detail to use 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 description coverage is 0%, yet the description provides no explanation of the two parameters (sessionId and checkpoints) or their sub-properties (label, dueHint, description). The context 'breaking a task into steps' loosely implies checkpoints are steps, but it's not explicit.

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 is for breaking tasks into measurable steps (checkpoints) to make progress auditable. The verb 'add_checkpoint' is specific and distinct from sibling tools like 'update_checkpoint' or 'add_evidence'.

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?

Explicitly says 'Call this when breaking a task into measurable implementation or research steps,' providing clear context for when to use it. Does not mention exclusions or alternatives, but the usage scenario 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 carries the full burden. It mentions the types of evidence and linking to done criteria, but it does not disclose side effects (e.g., whether it appends or replaces), error handling, or return values. For a simple add operation, some transparency is present, but more detail would be beneficial.

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 concise: two sentences front-loaded with the core usage instruction. Every sentence adds value, and there is no fluff. It is appropriately sized for the tool's simplicity.

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 8 parameters with 0% schema description, the description is minimal. It lacks details on how evidence integrates with the session, the effect on checkpointIds and doneCriterionIds, and the overall behavior. For a tool in a task management suite, more context is needed for correct 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 0%, so the description must compensate. It adds meaning by listing evidence kinds (tests, typecheck, etc.) and mentioning 'paths, or URLs', which correspond to parameters. However, it does not explain many parameters like sessionId, checkpointIds, doneCriterionIds, or command, leaving gaps in 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 purpose: 'Call this whenever you have proof of progress' and lists specific evidence types (tests, typecheck, lint, etc.). It effectively distinguishes from sibling tools like taskguard_add_checkpoint or taskguard_update_criterion, which deal with different concepts.

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

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

The description gives clear guidance on when to use it ('whenever you have proof of progress') and instructs to link evidence to done criteria. However, it does not explicitly state when not to use it or directly contrast with alternatives among siblings, though the context implies its specific role.

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 provided, so description must bear full transparency. It reveals the tool 'warns' about scope drift, implying a read-only check. However, it does not disclose return format, side effects, 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?

Two sentences, no redundancy. The first sentence is slightly dense but functional. Efficient for the information conveyed.

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 three undocumented parameters, the description is notably incomplete. It lacks return value behavior, parameter details, and edge-case handling (e.g., when changedFiles is provided).

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 0% and description gives no explanation of any parameters (sessionId, changedFiles, proposedAction). With three parameters, the tool name and purpose loosely imply proposedAction is the action to check, but no explicit semantics are provided.

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

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

Description clearly states the tool checks if proposed action is within task contract, using specific verb 'check scope drift' and resource 'task goal'. It differentiates from siblings (e.g., add_checkpoint, verify_done) by focusing on drift detection before action.

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?

Description explicitly advises calling 'before' specific cases (adjacent cleanup, broad refactors, extra features). It lacks explicit alternatives or when-not, but the examples and context are sufficient for appropriate use.

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 explains this tool defines a contract for later use, but does not disclose behaviors like overwriting on repeat calls, required permissions, error states, or return values. Basic transparency is present but incomplete.

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: the first gives an actionable directive ('Call this before starting meaningful work'), the second defines the function. No unnecessary words; 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 description explains how this tool feeds into sibling tools (scope drift detection and verification), providing cross-tool context. Given moderate complexity (5 params, no output schema), it reasonably covers when and why to use it, though it lacks details on return value and default behaviors.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'goal, non-goals, and explicit done criteria' which map to three of five parameters, providing context. However, it does not clarify 'title' or 'sessionId', nor detail the structure of 'doneCriteria' (objects with description and optional required).

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 as 'defines the task contract' including goal, non-goals, and done criteria. It distinguishes this from sibling tools (checkpoints, evidence, etc.) by positioning it as the initial step before meaningful work.

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

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

The description explicitly says 'Call this before starting meaningful work,' providing clear timing guidance. While it does not list alternative tools or when to avoid, the sibling context (e.g., taskguard_check_scope_drift for later) implies this is the setup tool, making it effective.

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 disclose behavior. It states the tool returns the active task ledger or a specific session, which implies a read operation. However, it does not mention permissions, side effects, or any constraints beyond that. The disclosure is adequate but minimal.

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 usage context, and contains no redundant information. Every word serves a 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 simple read tool with no output schema and basic parameters, the description covers when to use and what it returns. However, it lacks details on parameter semantics and output format, which are important for an agent to invoke it correctly. It is adequate but not comprehensive.

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

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

Schema description coverage is 0% and the description does not explain the parameters (sessionId, includeArchived) at all. The input schema provides only type info, so the agent gets no guidance on how to use these parameters. The description adds no value 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 clearly states the tool's purpose: 'Returns the active task ledger or a specific session.' It identifies when to call it (resuming work, user asks what remains) and distinguishes it from sibling tools, which are for adding or updating task items.

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 usage context: 'Call this when resuming work or when the user asks what remains.' While it doesn't mention when not to use or name alternatives, the context is clear and the sibling tools' names imply they are for different actions.

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 states the tool 'records rationale for later review', indicating a write operation with no destructive behavior implied. This is clear enough, though it could mention whether the record is append-only or overwrites, and if any authentication is needed.

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

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

The description is two concise sentences, front-loaded with usage context. Every sentence serves a purpose: the first tells when to use it, the second explains the outcome. 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?

Given the tool has 4 parameters (2 required), no output schema, and no annotations, the description is incomplete. It does not clarify what 'sessionId' refers to (likely a session identifier) or how 'alternativesConsidered' should be used. The return value is not mentioned. While the core use case is clear, details are missing.

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

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

Schema description coverage is 0% (no parameter descriptions in the schema), so the description must compensate. It mentions 'decision' and 'rationale' implicitly but does not explain 'sessionId' or 'alternativesConsidered'. The description adds minimal meaning beyond the parameter names.

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: recording decisions when choosing an implementation approach, rejecting alternatives, or determining scope. It uses specific verbs ('record', 'choosing', 'rejecting', 'deciding') and names the resource ('decision'), which distinguishes it from sibling tools like taskguard_add_checkpoint or taskguard_check_scope_drift.

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

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

The description explicitly lists three concrete scenarios for using the tool: choosing an approach, rejecting an alternative, or deciding scope. This provides clear context, though it does not explicitly mention when not to use it or compare it to alternatives like taskguard_check_scope_drift. Still, the guidance is strong.

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 mentions that archiving preserves audit history, implying delete removes it, but does not explain what 'reset' actually does to the session (e.g., clears checkpoints, marks incomplete, etc.). Partial transparency.

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

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

Two concise sentences that front-load the essential purpose and usage guidance. Every word earns its place; no redundancy or fluff.

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

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

Given a simple tool with two parameters and no output schema, the description covers usage context (when to call, preference) but lacks details on what the tool does to the session state. Slightly incomplete for full understanding.

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

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

Schema description coverage is 0%, so the description must add meaning to parameters. It does not describe sessionId (identifies session) or mode (archive vs delete) beyond what the enum values already convey. The description adds no parameter context.

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 explicitly states the tool's purpose: resetting a TaskGuard session when the user abandons, restarts, archives, or deletes it. This clearly distinguishes it from sibling tools like taskguard_add_checkpoint or taskguard_define_goal, which perform different actions.

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 concrete when-to-use guidance: 'only when the user abandons, restarts, archives, or deletes' a session, and adds a preference: 'Prefer archive over delete to preserve audit history.' This helps the agent choose correctly among siblings.

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 provided. Description adds the behavioral insight that open blockers block verification, but does not disclose other traits (e.g., idempotency, required permissions, or side effects of status change).

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, zero waste. Front-loaded main action and adds relevant context about verification dependency.

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 update tool with no output schema, description explains when to use and a related consequence. However, lacks detail on input parameters and fails to mention what resolution is for, leaving gaps for a new user.

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

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

Schema description coverage is 0%. Description does not explain sessionId, blockerId, or resolution fields. The hint to use 'resolved' or 'waived' for status adds some meaning, but fails to guide on the required identifier parameters.

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?

Description clearly states the tool updates blocker status when resolved or waived. It distinguishes from sibling taskguard_add_blocker by focusing on updates, and provides context linking open blockers to taskguard_verify_done.

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?

Explicitly says when to call: when a blocker is resolved or waived. Implicitly excludes creation via sibling name, but does not explicitly state when not to use (e.g., for opening a blocker).

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 that the tool updates a checkpoint's status and optionally attaches evidence. However, it lacks details on side effects (e.g., whether it overwrites evidence), authentication requirements, or idempotency. The description is 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?

Two concise sentences: the first states the purpose and trigger, the second encourages evidence. No unnecessary words. Front-loaded with the most critical information. Highly 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?

The tool has 5 parameters, a nested object, and no output schema. The description does not explain return values or required fields beyond the trigger events. It briefly mentions evidence but omits rationale and identifiers. Sufficient for a simple status update but incomplete for full context.

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

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

Schema description coverage is 0%, and the description does not explain any parameter beyond a general mention of 'evidence.' The description fails to add meaning to parameters like sessionId, checkpointId, rationale, or the evidence object structure. The schema is self-explanatory for enums, but the description should have compensated for the lack of schema descriptions.

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

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

The description clearly states the verb (update) and resource (checkpoint), with specific trigger events: 'after starting, completing, or intentionally skipping a checkpoint.' This distinguishes it from sibling tools like taskguard_add_checkpoint (add vs update) and taskguard_add_evidence (separate evidence addition).

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

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

The description explicitly says when to call the tool (after starting, completing, or skipping a checkpoint). It also advises to attach evidence 'whenever possible.' However, it does not explicitly state when not to use it or compare to alternatives, though sibling names provide implicit differentiation.

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

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

With no annotations, the description must fully disclose behavior. It mentions that the tool updates status and that evidence should be linked for met criteria, but it omits other behavioral traits such as side effects, permissions, or what happens to previous evidence. The lack of detail leaves the agent uncertain about the tool's implications.

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 concise with two sentences. The first sentence states the primary use, and the second adds a condition. Information is front-loaded effectively. 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?

Given the tool has 5 parameters, no output schema, no annotations, and 11 sibling tools, the description is too minimal. It does not explain the overall workflow, how this tool relates to others (e.g., 'taskguard_add_evidence'), or error conditions. The agent lacks sufficient context to use it reliably.

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

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

Schema description coverage is 0%, so the description should compensate. It explains the 'status' enum and hints at 'evidenceIds' linking, but it does not elaborate on 'sessionId', 'criterionId', or 'rationale'. The description adds some value but is insufficient to fully clarify the parameters.

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 updates the status of a done criterion to 'met', 'not_met', 'pending', or 'waived'. It specifies the resource (criterion) and action (update). However, it does not explicitly differentiate from sibling tools like 'taskguard_verify_done', though the verb and context hint at uniqueness.

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 guidance on when to call: when a criterion's status changes. It also adds a condition about linking evidence in strict verification. However, it does not mention when not to use this tool or suggest alternatives among siblings.

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 fully disclose behavior. It describes the verification action but omits details like side effects (read-only?), error handling on failure, or whether it blocks or returns a boolean. This is insufficient for an agent to understand the tool's behavioral impacts.

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 usage context, no fluff. Could be slightly improved by adding parameter explanations without verbosity.

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 and two parameters, the description is incomplete. It covers purpose and usage but lacks parameter semantics and behavioral transparency. Sibling list suggests a family of tools, but no guidance on how verify relates specifically to the others.

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 0% meaning description adds no explanation for parameters. The 'strict' parameter (boolean, default false) is not mentioned at all, leaving the agent without guidance on its effect. SessionsId is required but not described.

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?

Description clearly states it checks done criteria, checkpoints, blockers, and optional evidence to prevent false completion. Verb 'verify' and resource 'done' are specific, and the context of final response, commit, PR, or handoff distinguishes it from sibling tools that add or update task data.

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?

Explicitly says call before final response, commit, PR, or handoff, providing strong usage timing. However, does not mention when not to use or alternatives if criteria are not met.

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