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

With no annotations, the description carries the full behavioral disclosure burden. The verb 'Check' implies a read-only diagnostic actionchers, which is a meaningful behavioral signal. However, it does not state what happens on success/failure, whether any system state can be changed, or what output the agent should expect, leaving important behavior 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, direct sentence with no filler or redundant wording. It front-loads the action and lists the specific resources being checked, making it easy for an agent to parse quickly.

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

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

For a zero-argument diagnostic tool, invocation is trivial and the description is sufficient for initial selection. However, with no output schema, the agent is not told what kind of result to expect or how to interpret the check outcome. The phrase 'initialization' is somewhat vague, so the definition 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?

The tool has zero parametersched, so schema coverage is trivially 100% and there is no parameter meaning to add. The baseline of 4 for no-parameter tools applies here because the description and schema are consistent and no parameter documentation is needed.

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, 'Check', and names distinct resources: Node, CodeBuddy CLI, and ACP stdio initialization. This clearly communicates a diagnostic/health-check tool and differentiates it from the session-management siblings. It could be slightly stronger by stating the expected outcome (e.g., 'report environment readiness'), but the core purpose is understandable.

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 guidance on when to use this tool instead of siblings like workbuddy_status or workbuddy_session_status. There is no mention of troubleshooting contexts, prerequisites, or scenarios where this should not be used. The usage intent must be inferred entirely from the tool name and the word 'Check'.

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 restates the basic listing action and does not clarify whether the tool is read-only, whether it requires an active session, whether it triggers new work, or what happens when no session exists.

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 redundancy. It front-loads the primary action and resource, 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?

Given the zero-parameter schema and simple listing intent, the description is close to sufficient, but it remains vague about session lifecycle and what 'new response' means. An agent would need to infer timing and valid call contexts from sibling tool names rather than from the description itself.

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 zero parameters, so parameter semantics have minimal impact. The description adds a little context by indicating the models are tied to the current session/new response, but since there are no parameters to document, the baseline of 4 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 names a specific verb ('List') and resource ('models returned by the current WorkBuddy ACP session/new response'), which is more than a tautology and distinguishes it from session-action siblings. However, the phrase 'session/new response' is slightly ambiguous about whether it refers to an existing session's models or a newly returned response.

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

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

There is no explicit guidance on when to call this tool versus alternatives such as workbuddy_session_status or workbuddy_session_send. The context is implied by sibling names, but the description does not state prerequisites like requiring an active session or that this should be called after a response is generated.

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 implies a destructive action ('cancel') but does not specify side effects, reversibility, authentication requirements, or what happens to the session. This is a significant 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 a single, short sentence with no filler words. It is front-loaded with the action. While it lacks detail, that is a completeness issue, not a conciseness issue. Every word earns its place.

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

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

For a simple tool with one parameter but zero annotation coverage and no output schema, the description is severely incomplete. It fails to explain the taskId parameter, any preconditions, or what 'active' means. An agent cannot reliably call this tool with the provided 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 one required parameter, taskId, with no description. Schema description coverage is 0%, so the description must explain what taskId refers to. It does not, leaving the agent to guess what value to provide, which is critical for correct invocation.

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 'Cancel' and the resource 'active WorkBuddy session', which is specific. However, it does not distinguish from the sibling 'workbuddy_session_close', which likely has a similar or overlapping purpose. An agent might not know when to use this tool vs the close tool.

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 'close' or 'send'. There are no conditions, prerequisites, or exclusions mentioned. The description only states the action without any context on when it is 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?

Describes the core effect (closing the process and marking the task completed) but does not disclose side effects, reversibility, or error states. With no annotations provided, the description carries the burden and only partially covers it.

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?

Single sentence with no redundant wording. The verb and object are front-loaded, and every word earns its place.

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

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

Adequate for a simple close operation but lacks usage context and parameter clarification. It does not explain how it relates to other session tools or what state the process should be in, leaving some ambiguity for an agent.

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?

Does not explain the taskId parameter beyond its existence. Since schema coverage is 0%, the description should clarify that taskId identifies the task to close, but it omits this entirely, leaving the agent to infer its role.

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

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

States exactly what it does: closes the local ACP process and marks the task completed. This clearly distinguishes it from sibling tools like session_start or session_send, and the verb-resource pair is 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?

Offers no guidance on when to use this tool versus alternatives like session_cancel or session_send. It does not mention prerequisites, ordering, or conditions that would make this the correct choice.

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 a raw response payload is required and advises not to invent a format if an explicit schema is given. It also mandates a status check. However, it does not mention side effects (e.g., whether the reply resolves the pending request), error conditions, or return behavior. This is adequate but not fully transparent for a mutation-like action.

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 with no redundancy. The first sentence states the core purpose, and the second provides essential guidance (check status, use raw payload). It is front-loaded and every word earns its place.

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

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

With 3 required params, no output schema, and no annotations, the description should provide more context. It offers a prerequisite and payload guidance but omits where to obtain taskId and requestId, what constitutes a valid response, how errors are surfaced, and the effect of a successful reply. It is sufficient for a simple call but leaves an agent inferring missing details.

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 only 33% (only 'response' has a description). The description adds context for 'response' (raw payload, version-specific) but does not elaborate on 'taskId' or 'requestId' beyond their names, which are likely identifiers from the status. The description partially compensates for the low schema coverage but does not fully explain how these IDs relate to the pending request.

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

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

The description states a specific verb ('Reply') and a specific resource ('a pending ACP permission request'). It clearly distinguishes this from sibling tools like workbuddy_session_send (for general messages) and workbuddy_session_status (for inspection) by specifying the permission-reply context. The purpose is unambiguous.

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

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

The description explicitly instructs to 'Inspect workbuddy_session_status first', providing a clear prerequisite and ordering. It implies this tool is only for pending permission requests, but does not explicitly state when not to use it or name alternative tools. Still, the context is clear enough for an agent to know when to invoke it.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the report is in-memory and not persisted, and 'Read' implies non-mutation. However, it does not cover failure cases (e.g., incomplete prompt or unknown taskId) or whether reading affects the report.

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 tightly written sentences, with the core purpose front-loaded and the critical limitation in the second sentence. No filler or redundant restatement of the tool name.

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

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

Given no annotations and no output schema, the description should say a bit more about report availability/format. It covers purpose and a key storage caveat, but an agent must infer what a successful response contains and when the report may be absent.

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 the description never explicitly defines taskId; it only implies via 'completed prompt' that the taskId identifies that prompt. The single parameter's name is conventional and self-explanatory, so an agent can infer it, but the description should have stated the mapping directly.

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

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

States a specific verb ('Read') and resource ('in-memory report produced by a completed prompt'), and is clearly distinct from the sibling session lifecycle tools (start/send/status/cancel/close/permission). The non-persistence note further sharpens what this tool does.

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 clear usage context: the tool is for reports after a prompt has completed, and 'not persisted in the task registry' warns against expecting later retrieval. It does not explicitly name alternatives or when-not-to-use conditions, but the context is sufficient.

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 responsibility for disclosing behavioral traits. It only states the action without revealing side effects (e.g., message delivery, session state changes), requirements (active session), or error behavior. The agent is left guessing about potential mutations or constraints.

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, front-loaded with the action. It is appropriately short, though it could add a bit more context without becoming verbose, hence not 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?

For a tool with no annotations and no output schema, the description is insufficiently complete. It lacks parameter explanations, usage context, and behavioral expectations, making it inadequate for an agent to reliably select and invoke the tool.

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

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

Schema description coverage is 0%, so the description must compensate by explaining taskId and message. It does not mention either parameter, leaving their meaning and purpose completely undocumented. This is a critical gap for a tool with only two required 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 states a specific verb ('send') and a resource ('follow-up message to the same WorkBuddy session'), which clearly indicates the action and distinguishes it from start, cancel, close, and status. However, it does not elaborate on what 'follow-up' implies or contrast with permission_reply, leaving some 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?

The description implies usage within an existing session ('same WorkBuddy session') but provides no explicit guidance on when to use it versus alternatives, nor when not to use it (e.g., when no session exists). No exclusions or prerequisites are mentioned.

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 carry behavioral disclosure. It discloses the asynchronous default (taskId returned immediately, poll status for report) and the blocking alternative. However, it does not mention potential side effects, permission implications, or the fact that it initiates a potentially long-running process. The schema mentions permissionMode dangers but the description does not reinforce this.

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 with no filler. It front-loads the core purpose and then provides essential behavioral guidance. Every word adds value.

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

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

For a session-start tool with 7 params and no output schema, the description covers the key workflow aspects (immediate vs blocking, polling). It does not explain the return format beyond taskId, but that is implied. It also does not mention prerequisites like cwd existence, though that is in the schema. Overall, it is adequately complete for an agent to call it correctly.

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

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

Schema description coverage is 71%, above the 50% threshold, so baseline is 3. The description adds workflow context (poll status, request report) but does not provide extra meaning for individual parameters beyond what the schema already documents. The schema already covers backend, permissionMode, and waitForCompletion well.

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 'Start' and the resource 'WorkBuddy session', making the purpose unambiguous. It also distinguishes itself from sibling tools like send/status/cancel by describing the session initiation behavior.

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 guidance on the two usage modes (default immediate return vs. waitForCompletion=true for blocking) and the associated polling workflow. However, it does not explicitly contrast with sibling tools (e.g., when to use send instead of start), so it lacks explicit exclusions or 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, the description carries the behavioral burden and does a good job: it explicitly marks the operation as a read and discloses the key side-effect-free trait of not sending a prompt. It does not elaborate on return shape or error cases, but for a status read that is a minor gap.

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

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

A single, front-loaded sentence that states the operation, the object, and the key qualifier with zero filler. Every word earns its place.

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

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

For a low-complexity, one-parameter read tool, the description covers the essential invocation facts: what is read, what is returned conceptually, and that no prompt is sent. It omits an explicit return format and prerequisites, but the absence of an output schema and simple scope keep this from being a major gap.

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

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

The schema provides no description for taskId (0% coverage), and the tool description never explicitly defines it. 'task/session status' implies taskId identifies a session, but no format, ownership, or lifecycle context is given, so the description does not compensate for the empty schema.

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

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

The description names a specific verb ('Read'), a concrete resource ('task/session status and any pending ACP permission requests'), and adds a distinguishing qualifier ('without sending a prompt'). This clearly separates it from action-oriented siblings like workbuddy_session_send or workbuddy_session_cancel.

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 'without sending a prompt' implies this is the safe status-checking alternative to session_send, but the description never states when to prefer it over workbuddy_status or the session action tools. No explicit when-to-use or when-not-to-use guidance is provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'List' conveys a read-only query and 'persisted' clarifies that it reads durable state rather than live sessions, but the description does not mention return format, ordering, or whether any filtering applies.

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. Every word contributes to identifying the resource and the kind of result returned.

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 parameterless, read-only list tool with no output schema, the description is largely sufficient: the agent knows what action to take and what resource is involved. It loses one point because it does not explicitly distinguish task status from session status among the closely related 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?

The tool has zero parameters, so there is nothing for the description to add beyond what the schema already conveys. The baseline of 4 applies because parameter semantics are not a meaningful gap here.

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 ('List'), a defined resource ('persisted WorkBuddy tasks'), and a clear output focus ('current lifecycle status'). It is unambiguous and can be distinguished from siblings by resource type, though it does not explicitly name workbuddy_session_status as the session-focused alternative.

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

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

No guidance is given about when to use this tool versus the sibling workbuddy_session_status or other session tools. The description implies it is for querying persisted tasks, but it does not state exclusions or point to alternatives for session-level status.

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