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

With no annotations provided, the description carries the full behavioral disclosure burden. It fully discloses destructive effects: deletion from memory and disk, disappearance of the transcript resource, error behavior for unknown ids, and the precondition that active runs must be stopped first. This is exemplary for a destructive tool without annotation support.

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, front-loaded with the primary action, and every sentence adds necessary information: the scope of deletion, the error case, the side effect on transcripts, and the required precondition. There is no redundant or filler content.

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

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

For a simple one-parameter destructive tool with no output schema, the description covers everything an agent needs: what is deleted, from where, what error to expect, what happens to related resources, and how to safely prepare a session for deletion. No important context is 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 coverage is 100%, and the single parameter session_id is already described as 'Id of the session to delete (see freebuff_sessions).' The tool description mostly reiterates the id-based deletion without adding substantial new semantics beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb and resource: 'Delete a Freebuff agent session by id — from memory and disk.' This clearly distinguishes it from sibling tools like freebuff_stop, freebuff_sessions, freebuff_run, and freebuff_status, which handle different operations. The scope and effect are 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 states when the tool should not be used by saying active runs must be cancelled with freebuff_stop before deleting their session. It also warns that deleting an unknown id returns an error, giving the agent the context needed to call the right tool at the right time.

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 does this well by explicitly stating that the default agent 'cannot modify anything' and that the alternative agent can 'edit files and run commands,' plus it discloses return content and session persistence. It doesn't cover failure/cost edge cases, but the core behavioral risks are 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 three short paragraphs with the main purpose front-loaded, followed by safety-relevant detail and session continuation. It is concise and free of filler, though it could be slightly tightened without losing 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 tool with 8 parameters and no output schema, the description covers the essential launch behavior, the read-only vs editing distinction, the return value, and conversation continuation. It doesn't include examples or error/edge-case details, but it provides enough for an agent to 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 description coverage is 100%, so all eight parameters are already documented structurally. The description adds useful context for 'agent' and 'session_id' (default behavior, continuation), but does not add meaning beyond the schema for cost_mode, max_steps, timeout_seconds, or force_resume. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Run'), a resource ('Freebuff coding agent'), and a context ('inside a workspace folder'). It clearly differentiates this from the sibling tools (freebuff_status, freebuff_delete, freebuff_stop, freebuff_sessions), which manage existing runs rather than launching new ones.

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 explains when to use the default read-only agent vs the editing agent ('Pass agent: 'codebuff/base@0.0.16' to let the agent edit files and run commands'), giving condition-based usage guidance. It does not explicitly mention when to prefer sibling tools, but the purpose separation is clear enough.

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 behavioral burden. 'List' clearly signals a read-only operation, and 'known to this server (memory + persisted on disk)' usefully discloses the data source and scope. It does not mention ordering, whether all session states are included, or error behavior, but these are minor for a simple list operation.

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

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

The description is a single compact sentence with no filler. It front-loads the action ('List'), then the resource ('Freebuff agent sessions'), then useful scope detail ('known to this server', 'memory + persisted on disk'). Every phrase 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 zero-parameter list tool, the description is largely complete: an agent knows what the tool does and where the data comes from. However, there is no output schema and no explicit note about what a returned session contains, such as an ID or status field, which would be helpful for chaining with freebuff_status or freebuff_delete.

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 and schema coverage is 100%, so there are no input arguments for the description to clarify. The baseline of 4 applies because there is nothing meaningful left undocumented.

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 and resource: 'List Freebuff agent sessions'. It also adds scope ('known to this server (memory + persisted on disk)'), making the operation concrete. While it does not name a sibling, the plural resource 'sessions' contrasts clearly with the action-oriented siblings freebuff_run, freebuff_status, freebuff_delete, and freebuff_stop.

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 intended use is implied by 'List Freebuff agent sessions', but the description gives no explicit guidance about when to choose this tool over siblings. It does not say, for example, to use freebuff_status for a detailed look at one session or freebuff_delete to remove one. With four related lifecycle tools present, some routing guidance would improve the definition.

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 behavioral disclosure burden. 'Check whether' signals a non-mutating verification and describes exactly what is checked (credentials, backend reachability). However, it does not mention possible side effects, network behavior, or what happens when credentials are invalid.

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

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

A single sentence that front-loads the action and directly states the tool's purpose with no filler, repetition, or unnecessary detail. 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 zero-input status tool, this is nearly complete: an agent can select and invoke it correctly based on the description alone. The main gap is the absence of return-value/output details, which matters more because there is no output schema and no annotations to clarify what the check returns.

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 and the schema is complete, so there is no parameter semantics burden. Per the rubric, a zero-parameter tool with full schema coverage gets a baseline of 4; the description adds no parameter information and does not need to.

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 action ('Check whether') and a specific resource/condition (Freebuff MCP server credentials and agent backend reachability). This clearly distinguishes it from the operational siblings freebuff_run, freebuff_delete, freebuff_stop, and freebuff_sessions, which all imply different purposes.

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 a health/credential-check use case, likely as a precondition before running other Freebuff commands, but it does not explicitly state when to use this tool versus siblings or when not to use it. Usage context is present but left to inference.

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

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

With no annotations, the description must carry behavioral disclosure. It does communicate a useful trait: the operation only acts on an existing running session ('if any'), implying a no-op when none is active. However, it does not mention side effects or whether cancellation is immediate, graceful, or irreversible.

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

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

A single sentence, front-loaded with the action ('Cancel') and the target ('currently running Freebuff agent session'), with no filler. Every word contributes to selection and invocation.

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 no-argument, single-purpose stop tool without an output schema, the description is nearly complete. The only minor gap is the lack of an explicit note about the destructive/irreversible nature of cancellation, though 'Cancel' largely conveys this.

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

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

The tool has zero parameters, so the baseline is 4; there is no parameter ambiguity for the agent. The empty input schema already represents this completely, and the description has nothing more it needs to add.

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 ('Cancel') and a specific resource ('currently running Freebuff agent session'), and the qualifier 'currently running' clearly scopes the action. This semantically distinguishes it from siblings like freebuff_sessions and freebuff_delete without 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 usage context is only implied: call this when a Freebuff agent session is running and should be cancelled. It does not explicitly say when not to use it or contrast it with freebuff_delete/freebuff_sessions, so the agent must infer the routing.

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