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

The annotations already indicate destructiveness. The description adds that memory, tasks, and messages are retained, and provides cleanup steps. This adds value beyond the annotations.

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 two short sentences covering purpose, retention, and cleanup. 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 no parameters, the description adequately covers the effect (deregister, retain data) and required post-steps. It is missing potential details like reversibility or confirmation, but these are not critical.

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?

No parameters, so description doesn't need to explain them. It adds meaning by describing the tool's effect on data retention and cleanup.

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 'Deregister yourself from Artel' and 'Removes your agent record from the server', providing a specific verb-resource pair. It distinguishes from siblings like agent_rename and agent_list.

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 context: it's for when you want to remove yourself from the fleet, and includes cleanup instructions. However, it does not explicitly state when not to use it or compare to 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds context about 'last active' meaning. However, it does not elaborate on other behavioral traits, but given annotations, the bar is lower.

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 sentences with front-loaded purpose, no wasted words. Every sentence 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 zero-parameter read-only tool with an output schema, the description is complete: it explains what, when to use, and a behavioral hint.

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 no parameters and schema coverage is 100%, so baseline is 4. The description does not need to add parameter info.

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 'List all registered agents and when they were last active,' providing a specific verb and resource. It distinguishes itself from siblings like agent_delete and agent_rename.

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 to use this to know who's available before sending messages or assigning tasks, giving clear context. It does not explicitly mention when not to use it or alternatives, but the context is clear.

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 already indicate non-destructive and idempotent behavior. The description adds valuable behavioral context by describing the cascading across memory, tasks, messages, and sessions, which is beyond the annotation hints.

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 short sentences with the core action front-loaded. Every sentence provides essential information: what it does, when to use, parameter format. 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 single-parameter tool with output schema present, the description covers the action, usage context, and effect on data. No gaps remain for an agent to misuse 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 coverage is 100% with the same parameter description. The description restates the schema text without adding new semantic information, so baseline 3 applies.

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

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

The description clearly states 'Rename yourself' and explains the cascading effect across data. It distinguishes itself from sibling tools as the only rename operation, and the verb-resource pairing 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?

Explicitly says when to use (ID mismatch or collision artifact) and restricts to self-rename. No mention of alternatives, but the restriction implicitly covers this since no other rename tool exists.

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?

The description discloses substantial behavior beyond the annotations: it creates only the first wave of tasks, auto-expands subsequent waves, includes fan-out from completed-task output, and does not require the caller to drive the run. This gives an agent a clear mental model of side effects and async behavior.

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

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

The description is front-loaded with the core purpose and then moves through the expansion model, caller responsibilities, and parameter usage without idle repetition. Every sentence adds operational context the agent needs.

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 stateful operation with automatic task expansion, the description is complete: it explains the lifecycle, how the agent should interact afterward, and how params behave. An output schema covers return-value details, so nothing essential 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 description coverage is 100%, and the Args section essentially restates the schema descriptions for name and params. The missing-parameters rejection and the example are already in the schema, so the prose adds no new 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 a specific verb and resource ('Start a blueprint run') and explains that instantiation scaffolds a self-expanding task DAG. It is clear about what the tool does, but it never explicitly contrasts itself with the sibling blueprint_run, so an agent must infer how the two differ.

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 strong post-call workflow guidance ('claim the next open task, do it, complete it, repeat') and implies that instantiation is for starting a blueprint-managed run. However, it does not explicitly say when to choose blueprint_instantiate over alternatives such as blueprint_run, or provide any when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description repeats this with 'Read-only, no side effects.' It does add helpful conceptual context about blueprints being procedures compiled into task DAGs, but it does not disclose output details or pagination behavior. The added value over annotations is modest.

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 short, front-loaded with the core action, and the blueprint definition earns its place. The final sentence about being read-only is redundant with the annotations, but it is brief and does not significantly harm conciseness.

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

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

For a zero-parameter list tool with an output schema and annotations covering the safety profile, the description is complete. It states what is listed, explains the domain concept, and directs the agent to the correct instantiation tool, so nothing essential 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?

The tool has zero parameters and schema coverage is 100%, so there is no parameter burden for the description to carry. The baseline for zero-parameter tools is 4, and the description appropriately adds no irrelevant parameter 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 uses a specific verb and resource: 'List the blueprints available to instantiate.' It also distinguishes this from the related blueprint_instantiate tool by explicitly naming that tool, so an agent can tell listing apart from instantiation.

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 useful context about blueprints and points to blueprint_instantiate as the follow-up action, implying the list is used to choose a blueprint. However, it does not explicitly state when to use blueprint_list versus alternatives like blueprint_run, nor does it describe when not to use 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?

Annotations already carry readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description repeats this with 'Read-only, no side effects' and adds the scoping detail that it shows tasks materialized so far. With annotations covering safety, the description contributes modest additional context — a fair 3.

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 purpose is front-loaded, followed by usage guidance and the read-only note, with no filler. The only redundancy is the Args block restating what the schema already documents, which is minor for a single parameter.

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 read-only tool with a present output schema and full safety annotations, the description covers purpose, usage, and the parameter. Nothing an agent needs to invoke it correctly is missing, though it adds little beyond what the schema and annotations already provide.

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 run_id parameter is fully described in the schema ('The run ID returned by blueprint_instantiate()'). The description repeats this exact text, so it adds no meaning beyond the schema. Baseline 3 is correct.

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 (Show) and resource (a blueprint run) and defines the content: 'its status and every task materialized so far.' This clearly separates it from blueprint_instantiate (creates a run) and blueprint_list (lists blueprints), so an agent can tell them apart without opening schemas.

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

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

'Use to see how far a run has expanded and which tasks are still open' gives explicit, actionable context for when to call it. It does not name alternative tools or state when not to use it, but the single clear use case is sufficient for a simple read operation.

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?

The description explicitly states the tool 'adds a pre-commit hook' to the repository, which is a mutation. However, annotations declare readOnlyHint: true, implying no state changes. This is a direct contradiction, making the behavioral transparency unreliable. The description adds useful context (safe no-op, stdlib-only) but the contradiction forces a score of 1.

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 front-loaded with the core purpose and then expands on the hook details, safety, and usage. Each sentence contributes value, and the structure is logical. It is slightly long but not bloated, earning a 4.

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 complexity of a setup tool, the description covers the essential aspects: purpose, the hook behavior, the no-op safety, the run-once instruction, and the parameter. The output schema exists, so return values don't need explanation. It is complete except for the annotation contradiction, which is a separate issue.

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 parameter description in the tool matches the schema exactly. The description adds no extra meaning beyond what the schema already provides, so it meets the baseline for high coverage without enhancing 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 states a specific action ('Set up compile mode') on a specific resource ('current git repo') and explains what compile mode does (adds a pre-commit hook). It clearly distinguishes itself from siblings like compile_status and compile_stale, which check status and stale memory rather than performing setup.

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 gives clear context: 'Run this once per repo' and 'Ask me "set up compile mode" anytime.' It implies this is the setup tool among the compile_* family, but it does not explicitly mention alternatives or when NOT to use it. Slight room for improvement in naming exclusions, but overall guidance is present.

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 already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false. The description adds meaningful behavioral context beyond that: it defines the staleness condition (SHA != HEAD) and advises recompilation before trusting the output. This goes beyond the annotation's safety profile without contradicting 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?

The description is succinct and front-loaded: the first sentence states the core purpose, the second adds the critical implication and guidance, and the Args block is minimal. No filler or redundant phrases. It earns its place without waste.

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 optional parameter) and has an output schema, so return format is not needed. The description covers what it does, why it matters, and how to use the parameter. Nothing an agent needs to call it correctly 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?

The input schema already provides full documentation for the single parameter 'project' (description: 'Restrict to a project. Defaults to MCP_PROJECT if set.'). The description's Args block repeats this verbatim, adding no new information. With 100% schema coverage, 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 states a specific action ('List') and resource ('compiled descriptions') with a precise condition (SHA != HEAD). It clearly distinguishes this from sibling compile tools like compile_status (which likely shows build status) and compile_setup (which sets up compilation). The purpose is unambiguous and actionable.

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 (to identify stale compiled descriptions) and provides follow-up guidance (recompile before trusting). However, it does not explicitly name alternatives or state when not to use this tool versus compile_status or compile_setup. The context is clear but lacks explicit exclusion.

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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds meaningful context beyond annotations by defining what 'fresh' and 'stale' mean, that compiled memory is SHA-stamped, and that authored memory is unaffected. This gives the agent a mental model of what the summary actually represents without needing to inspect the store.

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 core summary is front-loaded in the first sentence, and the explanatory second paragraph provides necessary conceptual context for interpreting the results. The 'Args' section is redundant with the schema, slightly inflating length, but overall the text is tight and every sentence contributes to understanding the tool's purpose and output semantics.

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

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

For a one-parameter tool with an output schema, the description covers the purpose, the meaning of fresheness/staleness, and the relationship to authored memory. The only notable gap is that 'code anchors' are not defined, though the context suggests they are locations in the codebase tied to compiled descriptions. Still, the conceptual model is sufficiently complete 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 100% and the parameter description in the schema is identical to the 'Args' text in the tool description. The description adds no new meaning beyond the schema; it merely repeats it. With full schema coverage, a baseline of 3 is appropriate, but there is no extra semantic value added.

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 a specific verb and resource: 'Summarize compile mode' and enumerates exactly what the summary counts (compiled descriptions, code anchors, stale count). This distinguishes it from siblings like memory_list (lists all memory) and compile_stale (presumably acts on stale items) through the focus on status and freshness.

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 the conceptual difference between compiled and authored memory, which implies when the tool is relevant (checking build-validated memory health). However, it never explicitly says when to use this tool instead of, say, memory_list or compile_stale, nor does it mention any exclusions. Usage guidance is implied rather than spelled out.

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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds one useful behavior beyond annotations: accepting short ID prefixes of at least 4 characters. It does not mention not-found or error behavior, but that is a minor gap for a simple getter.

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 core instruction is a single front-loaded sentence, and the overall description is short and scannable. The Args block is redundant with the schema, which prevents a higher score, but it doesn't create meaningful bloat.

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 one fully documented required parameter, an output schema available, and safety annotations present, the description plus structured metadata completely specify how to invoke the tool. No critical invocation 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?

The only parameter, decision_id, is fully documented in the input schema with 100% coverage, and the description repeats the same wording rather than adding new meaning. This meets the baseline but provides no 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?

Description opens with 'Fetch a single decision by ID' – a specific verb, resource, and selection mode. This clearly distinguishes it from siblings like decision_list (bulk retrieval) and decision_write (mutation).

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 'a single decision by ID' establishes a clear usage context: use when a specific decision UUID is known. However, it doesn't explicitly contrast with decision_list for listing/searching or decision_write for creating, so it stops short of explicit alternative routing.

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

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

Annotations already cover readOnlyHint and destructiveHint, so the safety profile is fully handled. The description adds ordering behavior (most recent first) and a practical usage note ('read before starting work'), which goes beyond annotations. No contradictions.

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?

Front-loads purpose and usage in two short sentences, then documents arguments. The Args block is redundant with the schema but standard practice; the overall length is appropriate and each sentence 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?

An output schema exists, so return values need not be described. The description covers ordering, use case, and available filters; all parameters are optional, so an agent can invoke it correctly with zero arguments. Adequate for the tool's complexity.

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

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

Schema coverage is 100% and the description's Args block repeats the schema's parameter text verbatim. It adds no extra meaning beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb (list), resource (decisions), and key behavior (most recent first). Clear distinction from siblings decision_get and decision_write is evident from the name and description, so an agent can tell them apart.

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 advises reading before starting work on something already decided, and points to memory_search as a complement for factual context. This gives strong when-to-use guidance, though it doesn't name exclusions such as decision_get for single-record lookups.

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?

The description clearly discloses that decisions are append-only, cannot be updated or deleted, and are irreversible. This adds important behavioral context beyond the annotations, which only declare destructiveHint false and openWorldHint false. An agent knows this is a permanent, high-commitment write.

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 front-loaded with the core purpose, then provides a concise differentiation from memory, followed by a compact args list. Every sentence contributes to correct usage; there is no redundancy or 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?

For a write tool with an output schema, all parameters are documented, the append-only semantics are explicit, and the tool's role among siblings is clarified. Nothing needed for a correct call 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 description coverage is 100%, so the schema already documents every parameter. The description largely restates these definitions, but it adds a helpful example for 'decision' ('Use SQLite over Postgres') and clarifies the intent of 'alternatives' as rejected options. This is adequate but not additive 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 opens with a specific verb-resource pair ('Record an irreversible decision') and immediately clarifies the tool's scope. It also distinguishes decisions from memory writes ('Memory captures what is true; decisions capture what was chosen and why'), which separates it from the memory_* sibling tools.

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

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

It states exactly when to use decisions ('choices that future agents should not re-litigate') and gives concrete examples like architecture picks and scope cuts. It also contrasts decisions with memory, but it does not explicitly mention the read-side sibling tools (decision_list/decision_get) or state when not to use 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?

Annotations provide destructiveHint: false and openWorldHint: false. The description adds that events are received in real time via SSE stream, providing behavioral context beyond the structured fields. No contradiction found.

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 (about 6 lines), front-loaded with the core purpose, then usage guidelines, then parameter details. Every sentence adds value with no redundancy.

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, the description covers purpose, usage, and parameters adequately. It mentions the SSE stream. However, it lacks details on error conditions or prerequisites (e.g., required subscriptions), but the output schema likely explains return values.

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 baseline is 3. The description's Args section largely mirrors the schema's parameter descriptions, adding no significant new meaning beyond examples already present in the schema. Thus, it does not improve upon 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 action: 'Emit a custom event to the Artel event bus.' It is specific with a verb and resource, and distinguishes itself from all sibling tools (none are event-related).

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 tool: 'for pub/sub signaling between agents,' with examples like announcing completions and progress updates. It does not explicitly mention when not to use it or alternatives, but the context is clear.

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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds non-obvious behavior: it does not trigger a fetch (archivist polls on schedule) and is scoped to 'visible to you.' This adds value beyond the annotations.

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?

Concise and well-structured: a one-sentence purpose, a usage sentence, a behavioral note, and a brief Args block. Every sentence serves a purpose, though the Args section duplicates schema info slightly.

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 an output schema (not shown), and the description mentions the kind of metadata returned (poll interval, last fetch timestamp). With one optional filter and a read-only operation, the description covers what an agent needs 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?

The only parameter, project, is fully documented in the schema ('Filter by project. Omit to list all accessible feeds.') and the description repeats that in the Args section without adding new meaning. Schema coverage is 100%, so baseline 3 is appropriate.

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

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

Clearly states the action (list), the resource (active RSS/Atom feed subscriptions), and scope (visible to you). Also specifies two concrete use cases (check for duplicates, find feed_id for unsubscribe), which distinguishes it from feed_subscribe and feed_unsubscribe.

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 tells the agent when to use this tool: before subscribing to check duplicates, or to find a feed_id for feed_unsubscribe. Also clarifies it does not trigger a fetch. However, it doesn't explicitly mention alternatives or when NOT to use it, though the sibling names make the contrast implicit.

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?

Discloses details beyond annotations: confidence, tags, archivist cleanup, project-scoping. No contradiction with annotations.

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?

Front-loaded with clear summary, followed by structured parameter list. Every sentence adds value, no waste.

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?

Covers all aspects: behavior, parameter details, project-scoping, polling intervals. Output schema exists, so return values are covered.

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

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

Schema coverage is 100%, and description adds context like 'Required' and default values beyond 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?

Clears states it subscribes to RSS/Atom feeds and writes items to memory. It distinguishes from siblings like feed_list and feed_unsubscribe by focusing on subscription creation and 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?

Explicitly describes when to use (subscribe to feeds) and project-scoping, but lacks explicit 'when not to use' 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?

The description goes well beyond annotations. It discloses that deduplication history is removed, memory entries are not deleted, and re-subscription may re-ingest previously seen items. Annotations only cover idempotent, non-destructive, and open-world hints, so the description provides crucial side-effect context.

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

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

The description is concise and well-structured. The core action is front-loaded, followed by a clear explanation of side effects and necessary input. No redundant sentences; every line 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 one-parameter subscription removal, the description fully covers how to call it (feed_list reference), what effect it has (dedup history removal), what it does not do (memory deletion), and future implications (re-subscription). With an output schema present, nothing critical 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 description coverage is 100% because feed_id already has 'ID from feed_list()' in the schema. The description repeats this hint but adds no new semantic meaning beyond the schema. Baseline 3 applies 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 clearly states the action: 'Unsubscribe from a feed and stop future polling.' This is a specific verb (unsubscribe) and resource (feed), and it is distinct from siblings like feed_subscribe and feed_list. No tautology.

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 a clear prerequisite (use feed_list() to find the feed_id) and implies the operation is the antonym of feed_subscribe, but it does not explicitly state when not to use it or name alternatives. This is clear context without formal 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?

Annotations are minimal (readOnlyHint=false, destructiveHint=false), so the description carries the burden. It reveals that the tool creates edges that affect node viability and triggers review for contradictions. However, it does not disclose potential side effects (e.g., what happens if an edge already exists), whether the operation is reversible, or any prerequisite conditions (e.g., nodes must exist). The description adds some behavioral context but leaves 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 concise: a single sentence for the core action, followed by a usage explanation, and then a clear argument list. It is front-loaded and avoids unnecessary words. However, the second sentence is somewhat dense and could be broken into shorter sentences for clarity.

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 presence of an output schema (context signal indicates true), the description does not need to explain return values. However, it lacks details about error conditions (e.g., invalid node IDs, duplicate edges) and prerequisites (e.g., nodes must exist). The tool operates in a context of memory modes, which is explained, but operational completeness is moderate.

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 baseline is 3. The description repeats the parameter list but adds context for the 'rel' parameter by listing it within the use-case narrative. However, it does not provide additional semantics beyond the schema, such as format constraints or examples. The added value is marginal.

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 typed edge between two graph nodes'. It specifies the resource (graph nodes) and the specific use case of connecting authored and compiled memory with relation types like 'contradicts' or 'corroborates'. This distinguishes it from sibling tools like graph_neighbors, which queries connections rather than creating them.

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 use the tool: 'Use to connect authored and compiled memory' and explains the effect of different relation types. It mentions the practical consequence that more connections increase node viability and contradictions flag for review. However, it does not explicitly state when not to use it or suggest alternatives, but the context is strong enough for effective selection.

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?

Beyond the readOnlyHint and destructiveHint annotations, the description discloses meaningful behavioral semantics: viability is derived from connectivity, fresh connections increase trust, and a bare node fades. It also flags the id-resolution limitation. These details materially shape an agent's expectations without contradicting the annotations.

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 front-loads the purpose, then packs edge types, viability semantics, and id constraints into a compact, scannable structure. Every sentence contributes useful information, and the Args section is minimal and non-redundant.

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 single-parameter read-only tool with an output schema, the description covers everything needed to invoke it correctly: what it returns, how to obtain a valid node_id, and what id resolution caveats apply. No critical 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% for node_id, so the baseline is 3. The description adds real value by specifying that 4-char prefixes are not resolved and that the id can be either a memory id or a code-anchor id. This is more than a restatement of the schema property.

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 a specific verb and resource: 'Inspect a node in the memory knowledge graph: its kind, typed edges, and viability.' It enumerates the edge types and explicitly differentiates this graph-neighbor inspection from related tools like graph_link or memory_get by focusing on connectivity and viability.

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 clearly establishes when to use the tool: when you need a node's kind, typed edges, and viability. It also provides concrete input constraints ('4-char prefixes are NOT resolved here, pass a full id'). It stops short of explicitly naming alternatives or exclusion cases, so it earns a 4 rather than a 5.

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?

The readOnlyHint and destructiveHint annotations already establish the tool is safe, and the description adds useful detail beyond that: it returns instructional content rather than performing scheduling, and it names the exact formats/daemons covered. No side effects or contradictions are present.

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 carry the entire message with no filler. The main purpose is front-loaded, and the supporting detail about target systems and idle reachability is concise and directly relevant.

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

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

For a read-only, zero-parameter instruction-retrieval tool with an output schema, the description is sufficiently complete. It states what is returned, for which systems, and why it matters. The only minor gap is the absence of explicit when-not-to-use guidance, but complexity is low.

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 full schema coverage, so the description is not required to explain parameter meaning. The baseline for no-parameter tools is 4, and the description adds no unnecessary parameter-related noise.

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 a specific verb and resource: 'Get instructions for scheduling automatic inbox checks.' It then specifies the two target systems (Claude Code CronCreate and OpenCode artel-watch daemon), which clearly distinguishes it from sibling tools like message_inbox or compile_setup.

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 context for when to use the tool: when you want to set up automatic inbox checks so other agents can reach you while idle. It does not explicitly name alternatives or exclusions, but the purpose is concrete enough that an agent can decide when this 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?

Beyond the destructiveHint annotation, the description reveals it is a soft-delete (content retained for audit), which is critical behavioral context. It also mentions owner-only restriction, adding significant 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?

Four concise sentences: purpose, ownership, soft-delete behavior, parameter. No redundant information; every sentence earns its place. Front-loaded with the core action.

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 delete tool with output schema, this description covers purpose, ownership, and side effects. It might lack error behavior (e.g., if entry not found or not owner), but those are not critical given the tool's simplicity. Nearly 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 coverage is 100%, so the baseline is 3. The description's 'Args' section duplicates the schema description without adding extra meaning (e.g., format, constraints, or examples). No added 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 'Delete a memory entry' with a specific verb and resource. It stands out among siblings like memory_update and memory_write, and adds the ownership constraint, 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 for deleting memories but does not explicitly contrast with alternatives (e.g., memory_update for modification) or state when not to use it. The prerequisite (owner only) is given, but no whether to use at all.

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 already declare readOnlyHint=true, destructiveHint=false, covering the safety profile. The description adds context that session_context invokes this tool automatically, which is a useful behavioral note. It doesn't discuss return format, but an output schema exists, so that burden is shifted. The description consistently reflects read-only behavior and adds the custom time-range nuance without contradicting annotations.

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 plus a parameter note. The primary action and scope are front-loaded, and the usage guidance directly follows. There is no fluff or redundant content; every sentence 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 single-parameter read-only tool with an output schema and annotations covering safety, the description is complete. It explains what it does, when to use it, and provides the parameter format. The mention of session_context's internal call gives useful context. Nothing an agent needs to invoke it correctly 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 schema already describes 'since' as an ISO 8601 timestamp with an example. The description repeats this in the Args section, adding minimal new information. It confirms the parameter's purpose (the timestamp to fetch changes after) but does not add syntax, constraints, or edge-case details beyond the schema.

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

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

The description states a specific verb ('Get') and resource ('memory') with a precise condition ('written or updated after a timestamp'). It clearly distinguishes from siblings by noting that session_context handles automatic catch-up, while memory_delta is for custom time ranges. The purpose is unambiguous and distinct from other memory tools like memory_list or memory_get.

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 states when to use: 'Use when you need to catch up on a specific time window.' It also tells when not to use it directly: 'session_context() calls this automatically since your last handoff, use memory_delta directly only if you need a custom time range.' This directly names the alternative and the condition that selects 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?

Annotations already cover read-only and non-destructive behavior; the description adds meaningful behavioral context beyond that: no truncation, full metadata return, and short-prefix resolution for entry IDs. It does not contradict the annotations.

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 and front-loaded with the core action and key differentiator. The Args block is redundant with the input schema, but the overall size and organization are 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 is simple, has one parameter, is annotated as read-only, and has an output schema that covers return values. The description provides the essential usage context, return behavior, and ID-prefix behavior, making it complete 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 coverage is 100%, and the description repeats the schema's entry_id explanation almost verbatim. It adds no new parameter meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description specifies a clear verb and resource: fetch a single memory entry by ID. It also distinguishes itself from sibling tools by emphasizing 'full content without truncation' and listing the metadata returned.

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 to use the tool: after memory_search() or memory_list() returns a truncated entry, or when a specific entry ID is known and full metadata is needed. It names the relevant sibling alternatives and gives the decision condition, leaving little 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds no contradiction. It adds useful context about filtering capabilities but does not detail authorization, rate limits, or pagination behavior. Still, with strong annotations, the description is sufficient.

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?

Very concise: a short intro, a clear usage differentiation sentence, and a bulleted argument list. No filler, every sentence serves a purpose. Well-structured for easy parsing.

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 6 optional parameters, full schema coverage, output schema present, and good annotations, the description covers the necessary context: filter semantics, usage pattern, and sibling relationship. Could mention return format briefly, but output schema covers that.

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 parameter descriptions in the schema are complete. The description provides minor additional examples (e.g., '0.7 to skip decayed entries' for confidence_min), but adds limited new meaning 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?

Description clearly states the verb 'browse', the resource 'memory entries', and the filter mechanism. It explicitly distinguishes itself from the sibling tool memory_search by contrasting 'search for relevance' vs 'list by tag or author'.

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 explicit usage guidance: 'Use when you want to survey a topic area.' and directly contrasts with memory_search, telling the agent exactly when to use list instead of search.

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 already set readOnlyHint=true and destructiveHint=false, and the description does not contradict them. It adds value by explaining semantic matching behavior and the truncation behavior of max_content_length, including that full content remains accessible via memory_get. No hidden side effects or additional constraints are disclosed, but none are evidently needed for a read-only search 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 clear lead sentence, usage guidance, and an Args list. Some minor redundancy exists between 'Search shared memory by meaning' and 'Uses semantic (embedding) search,' and the Args section duplicates schema descriptions, but the overall size is appropriate for a five-parameter tool.

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

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

The description covers when to use the tool, why it matters, how the search behaves, and all parameter semantics. It also mentions the relationship to memory_get for retrieving full content. With an output schema present, this 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?

Schema description coverage is 100%, and the description's Args section essentially restates the same parameter descriptions in prose. This adds little meaning beyond the schema, so the baseline of 3 applies. The only minor extra is clarifying the practical rationale for max_content_length in LLM contexts.

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 a specific verb and resource: 'Search shared memory by meaning.' It further distinguishes the tool from exact-keyword lookup by stating it uses semantic embedding search, and clarifies the shared-memory context. This clearly differentiates it from sibling tools like memory_list and memory_get.

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 usage guidance: 'Call this before starting work' and 'Always search before writing.' It also explains when it is useful, such as finding prior decisions and avoiding duplication. It does not explicitly compare against memory_list as an alternative, but the guidance is clear enough for an agent to know when to call 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?

Annotations already provide idempotentHint and destructiveHint. The description adds critical behavioral context like optimistic locking via expected_version, conflict rejection, and the requirement to own the entry. This goes beyond annotations.

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 using an Args list, each line serves a purpose, and it is not verbose. Every sentence 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 8 parameters, one required, and an output schema present, the description covers all necessary behavioral aspects, preconditions, and parameter behaviors, making it complete for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds clarifying phrases like 'Omit to leave unchanged' and explains the conflict behavior for expected_version. This adds meaningful context 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 state the action 'Update a memory entry you own.' It uses a specific verb and resource, and distinguishes from siblings like memory_delete and memory_write.

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 updating an existing entry, but does not explicitly state when to use this tool over alternatives, such as creating new entries with memory_write.

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 annotations only covering open-world and destructiveness hints, the description carries the transparency burden and does so well: it explains directive confidence forcing, decay behavior for skills, scoping rules, and the default project behavior. It reveals how different entry types behave after writing, which goes well beyond the minimal 'write an entry' statement.

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 typical, but nearly every sentence earns its place given the complex entry-type system and scope rules. The use-case bullets and 'Types'/'Scopes' sections are well organized and front-loaded with the core intent before the 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?

Given that an output schema exists, return-value documentation is unnecessary, and the description covers all six parameters, their defaults, and the behavioral nuances of each entry type. An agent has enough information to call this tool correctly in a wide range of scenarios without needing to open sibling schemas.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value by explaining the semantics of entry_type (memory/doc/directive/skill lifecycle), scope visibility, confidence interpretation, and default project resolution. It also reinforces the tags guidance in a way that helps the agent use them more effectively.

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 a clear verb-resource pair: 'Write something to shared memory,' immediately distinguishing it from read/update/delete/list siblings. The bulleted list of use cases (facts, decisions, bugs, plans, open questions) makes the tool's purpose concrete and actionable.

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 strong when-to-use guidance ('Use this often... Write whenever you learn, decide, or discover something worth keeping') and even states exclusions, such as doc entries being 'normally written by the archivist, not agents.' It does not explicitly name alternatives like memory_update for corrections, but the use cases and type-level guidance are clear enough for selection.

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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds key behavioral context: messages stay unread until mark_read is called, which is safe for concurrent agents. It also discloses deprecation status. This adds value beyond annotations but does not describe the return format or ordering. With annotations covering safety, a 3 is appropriate.

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 structured with a deprecation notice, a usage instruction, and an explanation of read semantics. It is reasonably concise, but the deprecation notice could be seen as extra fluff. Still, it earns its place by preventing misuse.

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-parameter read tool with an output schema, the description is largely complete. It covers when to call, how to handle messages, and its deprecation status. The main missing element is what the output looks like, but the output schema can cover that. It does not mention any edge cases (e.g., no unread messages), but these are minor given the annotations.

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?

There are no parameters, and the schema coverage is 100% (since there are none). The description does not need to explain parameters. Baseline 3 is fine because there is nothing 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 clearly states the tool reads unread messages, a specific and actionable purpose. It is distinguished from siblings like message_list (which likely lists all messages) and message_mark_read (which marks messages as read). However, the deprecation notice adds some ambiguity about its current role, slightly reducing clarity.

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 guidance: 'Call this at session start.' It also explains when to use message_mark_read: 'once you've processed a message.' It does not explicitly list alternatives, but the deprecation notice makes it clear that this tool is not for new work, implying alternatives exist. This is good but not perfect.

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 already mark this as read-only and non-destructive. The description adds meaningful context beyond those annotations: the tool is deprecated, still functional, and not intended for new work. It also clarifies that it returns full history rather than only unread messages. This exceeds the minimum expected from a read-only 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 front-loaded with the critical deprecation warning, then states purpose, usage, alternative, and parameter details in a compact, scannable structure. Every sentence contributes useful information without redundancy.

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 tool with two optional parameters, full schema coverage, an output schema, and safety annotations, the description covers deprecation status, scope, appropriate use, and the sibling alternative. Nothing needed for correct selection or invocation 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 description coverage is 100%, so the input schema already fully documents both parameters. The description repeats the same semantics for read and limit without adding syntax details, defaults, or constraints beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states 'List all messages sent to or from you (full history, not just unread)', which names a specific verb, resource, and scope. It also distinguishes itself from message_inbox by contrasting full history versus unread-only.

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 explicit when-to-use guidance: review past conversations, check for missed messages, or audit communication. It also names the alternative condition directly: 'For unread-only, use message_inbox() instead.' No inference is required.

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?

Description adds value beyond annotations: explains that messages leave the inbox (state change) and implies a read-only effect consistent with destructiveHint=false and idempotentHint=true. No contradiction.

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?

Concise at three short paragraphs, front-loaded with purpose and usage. The Args section repeats schema slightly but serves as a quick reference. 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 tool with one optional parameter and an output schema, the description covers purpose, usage, parameter behavior, and result. Could mention the output schema content but not required per rules.

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%, but description reinforces the parameter's optional behavior and the effect of omitting IDs, adding practical usage context beyond the schema's description.

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 ('mark messages as read') and the effect ('leave the inbox'), distinguishing it from sibling tools like message_inbox (retrieve) and message_send (send).

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 advises to call after processing from message_inbox(), and provides two usage modes: specific IDs or omit for all unread. This gives clear when-to-use and how-to-use guidance.

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

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

Annotations only carry openWorldHint=false and destructiveHint=false; the description adds meaningful context: delivery is async and the recipient sees it only when they call message_inbox(). The deprecation status is also disclosed. No contradiction with annotations.

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?

Well-structured and front-loaded: deprecation warning first, then purpose, usage, then args. Every sentence earns its place, and the critical deprecation signal leads the description.

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?

Complete for an async messaging tool: deprecation, delivery timing, recipient behavior, and param semantics are all covered. An output schema exists, so return-value details need no elaboration. Could add what happens on failure, but nothing essential 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%, so the schema already documents all three parameters. The description's Args section largely mirrors the schema; the only added value is noting subject 'helps the recipient triage.' Baseline 3 is appropriate since the description doesn't substantially enrich 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?

States a specific verb+resource ('Send a message to another agent's inbox') and opens with a DEPRECATED notice that clearly differentiates it from siblings like message_inbox, message_mark_read, and message_list. The recipient-routing detail (message_inbox()) ties it to the matching sibling.

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 lists when to use it ('async coordination: delegating work, sharing a finding, asking a question, or notifying another agent that something is ready') and when NOT to ('DEPRECATED... not where new work should go'). Names the receiving-side sibling (message_inbox).

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?

The description discloses key behavioral traits beyond the annotations: it replaces the previous membership, makes project-scoped memory and tasks visible, and sets unqualified writes to default to this project. These are meaningful side effects that are not covered by idempotentHint or destructiveHint. This adds substantial value for an agent deciding to use the 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: a direct first sentence states the core action, followed by a concise explanation of behavioral implications and a clear Args block. It is slightly verbose for a simple tool, but each sentence contributes to understanding the behavior and usage. The important information is front-loaded, making it 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 covers the purpose, usage timing, and behavioral consequences adequately. Since an output schema exists and is referenced, the description does not need to explain return values. For a single-parameter tool, it provides sufficient context for correct invocation without missing critical 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?

The schema already documents project_id as 'The project name to switch to,' and the description repeats this in the Args section without adding further semantics. With 100% schema coverage, the baseline of 3 applies. The description does provide contextual usage around the parameter, but it does not enrich its meaning 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 explicitly states 'Switch to a project, this becomes your single active project,' which clearly identifies the verb and resource. It also explains the effect of replacing previous membership, making it unambiguous and distinct from siblings like project_leave or project_list. This directly addresses what the tool does and differentiates it from related 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 gives explicit usage guidance: 'Join the project you're working in at session start.' It also implies when to use it for switching projects and clarifies the one-active-project model. While it does not explicitly name alternatives, the context is clear enough for an agent to infer when to invoke this tool versus project_leave or project_list.

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

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

Annotations already declare idempotent and non-destructive behavior consequentially, and the description adds meaningful context: project-scoped memories stop appearing in memory_search()/memory_list(), memory is retained for other members, and rejoining is possible. This goes beyond the structured annotations.

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 efficiently structured: core action first, then behavioral consequences, then the alternative, then the argument. Every sentence contributes useful information, with no filler or redundancy.

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, idempotent, non-destructive tool with an output schema and comprehensive annotations, the description fully explains the effect, side-effects on memories, and the rejoin path. Nothing needed for correct invocation 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 description coverage is 100% and the only parameter, project_id, is already described as 'The project name to leave.' The description repeats this exactly without adding new semantic detail, 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 states a specific verb and resource: 'Leave a project, removes you from its member list.' This clearly distinguishes it from sibling tools like project_join and project_members.

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 the consequences of leaving and explicitly mentions the alternative: 'You can re-join at any time with project_join().' While it doesn't enumerate all when-not-to-use cases, the context is clear enough for selecting this tool.

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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context about the default project and outgoing memory writes, but it does not disclose potential quirks like empty results, access restrictions, or pagination. This is acceptable for a read-only list 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 brief and front-loaded with the core purpose. The second paragraph adds legitimate usage guidance, and the default-project note is somewhat tangential to project_list but still useful context. Each sentence earns its place without unnecessary 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?

For a zero-parameter read-only tool with an output schema and annotations, the description is largely complete. It conveys what the tool returns, why it should be used, and relevant project context. Minor omissions like handling of unset MCP_PROJECT or access limitations do not materially impair 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?

There are zero parameters and schema coverage is 100%, so the schema defines everything. The description adds no parameter information, which is unnecessary here; the baseline of 4 applies because there are no parameters to document.

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 starts with a specific verb and resource: 'List all projects' with the exact fields returned ('members, memory count, and last activity'). It clearly differentiates from sibling tools like project_members by emphasizing the all-projects scope and aggregate 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?

The description explains when to use the tool: 'to understand what projects are active, who's working on what, and how much shared context each project has.' It provides clear use-case context but does not explicitly mention 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds a meaningful behavioral constraint not in annotations: 'Requires membership, non-members cannot enumerate a project's members.' It also specifies the return fields, adding context beyond the schema.

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 main description is front-loaded and concise, with every sentence earning its place. The trailing Args block is redundant with the schema but not verbose enough to hurt clarity significantly.

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

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

For a one-parameter tool with output schema and strong annotations, the description covers purpose, usage, return values, and access control. Nothing needed to invoke it correctly 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 description's Args section merely repeats the schema's parameter description ('The project name to inspect') without adding format, constraints, or additional semantics. Baseline 3 applies.

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

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

Description states a specific verb ('List') and resource ('agents currently in a project'), and clarifies the output (join timestamps). It distinguishes itself from siblings like agent_list (all agents) and project_list (projects) by focusing on membership within a single project.

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

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

Explicitly says when to use: 'Use before sending project-wide messages or assigning tasks to confirm who has visibility into the project's shared memory.' It also gives a prerequisite (membership). It does not name alternatives or state when not to use, so it misses the top tier.

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 already indicate readOnlyHint and no destructive behavior. The description adds that it returns handoff and memory entries, which is useful context beyond the annotations.

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?

Extremely concise: a direct instruction, a one-sentence explanation of return value and purpose, and a brief parameter note. 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 annotations and output schema, the description provides all necessary context: what the tool does, when to use it, what it returns, and parameter usage.

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 baseline is 3. The description repeats the parameter info from the schema without adding new 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 clearly states the tool's purpose: to return the last session handoff and memory entries, and it explicitly says to call it first. This distinguishes it from sibling tools like memory_get or session_handoff.

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 explicit instructions: 'CALL THIS FIRST at the start of every session, before doing any work.' It explains how it helps avoid repeating work and pick up where left off.

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 provide idempotentHint=true and destructiveHint=false, so the safety profile is already covered. The description adds useful behavioral context: it persists a summary, next steps, and in-progress task IDs, and explicitly states that this is the only record of the session's accomplishments. This goes beyond the annotations without contradicting them.

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 front-loaded with the critical action ('CALL THIS LAST'), followed by a concise functional overview and per-argument guidance. Every sentence adds value, and there is no filler or repetition of schema metadata.

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 state-saving handoff tool, the description covers purpose, timing, persistence behavior, retrieval via session_context, and parameter semantics. With an output schema present and annotations covering safety and idempotency, nothing essential is missing for an agent to invoke 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 coverage is 100% and the description reinforces each parameter. It adds extra guidance beyond the schema, particularly for summary: 'Be specific, this is your only record' and 'decisions made, blockers hit, context that would be lost otherwise.' This gives the agent a clearer sense of how to fill the 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 states a specific verb and resource: 'saves state for your next session.' It clearly differentiates from the sibling session_context, which retrieves the state, by explaining the handoff stores context that session_context later returns.

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 when to invoke the tool: 'CALL THIS LAST before your session ends.' It also explains the relationship to session_context, telling the agent that the next session's context will come from this call, which provides clear when-to-use guidance.

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

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

Annotations indicate non-destructive, non-open-world. Description adds that the task appears only after dependencies reach 'completed' status, which is beyond annotations.

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?

Description is succinct, with a clear first sentence, followed by behavioral explanation and Args section. 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?

With 2 required params, 100% schema coverage, and presence of output schema, the description is adequate for an 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?

Schema coverage is 100%, and description repeats parameter meanings. Adds value by clarifying the roles of task_id and depends_on.

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 action: 'Mark a task as blocked by another task.' It explains the effect on task listing and differentiates from sibling tools like task_remove_dependency.

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 states when to use: 'Use to model prerequisite chains before claiming downstream work.' Provides clear context for 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 already declare non-destructive, non-open-world behavior, and the description adds consistent context: the state mutation (status set to 'claimed', 'marks it as yours') and the side effect of writing a note to the task's comment log. No contradiction with annotations — claiming is a reversible, non-destructive mutation.

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?

Efficiently structured: deprecation warning front-loaded, then purpose, workflow guidance, and args. The Args section is somewhat redundant with the schema, but every sentence otherwise earns its place and the critical deprecation context leads.

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?

Complete for a claim tool: it covers purpose, workflow position, follow-up actions, and both parameters. An output schema exists, so return values needn't be described. Nothing an agent needs to call it correctly is missing, though it stops short of describing edge cases like claiming an already-claimed task.

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% — both task_id and body are already documented in the input schema. The description's Args section largely repeats this, adding only marginal context (task_id comes from task_list() or task_create(), body is a why-note). Baseline 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?

States a clear verb+resource: 'Claim an open task, marks it as yours and sets status to 'claimed''. This distinguishes it from siblings like task_create, task_complete, task_fail, and task_unclaim — each is a visibly different lifecycle action, so an agent can tell them apart without opening schemas.

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

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

Provides explicit when-to-use guidance: 'Always claim a task before working on it. This prevents two agents from doing the same work.' It also names the follow-up tools (task_complete, task_fail, task_unclaim) and the deprecation note ('not where new work should go') gives a when-not signal, though it doesn't point to a specific replacement tool.

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 already indicate non-destructive behavior. Description adds context that comments are appended to a chronological log and that status changes are logged automatically, providing sufficient behavioral transparency for this simple write 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?

Description is concise and front-loaded with the main action, followed by usage guidance and clarification, with no wasted sentences.

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 and the presence of an output schema, the description adequately explains purpose and parameters. Could mention that comments are appended chronologically, but the term 'chronological log' implies this.

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

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

Schema coverage is 100%, and the description restates parameter descriptions with no additional semantic or formatting details beyond what the schema provides, meeting baseline expectations.

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 specifies the verb 'Add' and the resource 'free-form comment to a task's chronological log', distinguishes from siblings by noting that status changes appear automatically, and clarifies the difference between task description and comment log.

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 states to use for recording progress notes and intermediate findings, and notes that status changes are automatic. Could be improved by contrasting with task_update for modifying the canonical spec, but overall clear.

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 minimal (destructiveHint=false, openWorldHint=false), so the description carries the full burden. It discloses critical side effects: the body is recorded in the task's comment log and visible to all agents, the output is shape-checked and can cause rejection if missing/mismatched when a completion_contract exists, and only the claiming agent may complete. This goes well beyond annotations and is essential for safe 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 somewhat lengthy but logically structured: it opens with the deprecation warning (high priority), then states purpose, usage rules, and finally parameter details. It front-loads the most decision-critical information (deprecation and alternatives) and keeps the rest organized. Minor redundancy with the schema text exists, but it does not detract from readability.

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 mutating task-completion tool with deprecation, permission restrictions, and a validation contract, the description covers all necessary aspects: when to use, when to use alternatives, parameter constraints and side effects, and deprecation status. No critical information is missing for an agent to invoke 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 100%, so the baseline is 3. The description adds context beyond the schema: body is the only record future agents have, and output is required/shape-checked under completion_contract. These nuances are valuable even though the schema text largely mirrors the description's parameter explanations.

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 action ('Mark your claimed task as completed') and the condition for invocation ('when the task's expected_outcome has been fully achieved'), and it distinguishes this tool from siblings by naming alternates (task_fail, task_unclaim) for different failure modes. The deprecation note further clarifies its role as legacy functionality, so an agent knows exactly what this tool does and when it is appropriate.

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 when-to-use guidance ('when the task's expected_outcome has been fully achieved'), when-not-to-use with named alternatives ('If you cannot finish the task, use task_fail() instead; if you are stepping away mid-work, use task_unclaim()'), and a clear deprecation directive ('not where new work should go'). It also specifies the caller restriction ('Only the claiming agent can complete it'), leaving no ambiguity about invocation 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?

The annotations only declare openWorldHint=false and destructiveHint=false, so the description carries the behavioral burden. It adds valuable context: the tool is deprecated but still operational, persists tasks across sessions, and setting completion_contract causes task_complete() to reject malformed or missing output. There is no contradiction with the annotations.

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 front-loaded with the deprecation warning and usage conditions, and it is organized clearly with a separate Args block. Some of that block is redundant with the input schema, but the complex completion_contract parameter and the cross-tool behavior with task_complete earn the extra detail. Overall it is appropriately sized for an 8-parameter tool.

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

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

The description covers the tool's deprecation, when to use it, duplicate-checking, persistence, and the completion-contract interaction with task_complete. All parameters are explained in either the description or the schema, and the context signal indicates an output schema exists, so return-value documentation is not needed. Nothing appears missing for an agent to call this 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 the schema already documents all eight parameters. The Args section largely paraphrases the schema and adds little new semantic meaning for most fields; even the completion_contract behavior and example are already present in the schema. This meets the baseline 3 because the description does not need to compensate for schema gaps, but it also does not substantially exceed 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 opens with a deprecation warning but immediately states the exact verb and resource: 'Create a task for yourself or another agent to pick up.' It clearly distinguishes the tool from task_list and task_complete by referencing duplicate-checking and the completion contract, and from most siblings by framing this as the creation path. The deprecation line adds a strong identity signal without obscuring what the 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?

The description explicitly says 'Use when there's a discrete unit of work that should be tracked, may be done by a different agent, or needs to survive across sessions.' It also provides a concrete alternative check: 'Check task_list() for duplicates before creating.' The deprecation warning supplies a clear when-not-to-use signal, so the agent can decide whether to prefer the harness functionality instead.

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 declare destructiveHint=false and openWorldHint=false, which is somewhat consistent since marking a task as failed is not destructive in a data sense but is a state change. The description adds that it 'unblocks other agents' and that the body is recorded on the comment log, which is useful behavioral context beyond annotations. It does not contradict annotations, so a 4 is appropriate.

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, starting with a deprecation notice, then the core action, then usage guidance. It is slightly verbose with the deprecation notice taking prime space, but it's important for routing agents to alternatives. The content is concise and front-loaded with the most critical info.

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 complete for the tool's purpose, including deprecation status, usage guidance, and why to use it over alternatives. The output schema exists but the description doesn't explain return values, but that's not necessary since output schema exists. It covers prerequisites (claimed task) and the effect on other agents. Slight gap: no mention of prerequisites like being a claimer, but that's implied.

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 description explicitly explains both parameters: task_id is 'ID of a task you have claimed' and body is 'Optional reason recorded on the task's comment log. Strongly recommended.' This adds value beyond the schema, which only gives terse descriptions. The description also provides rationale for using body, which is helpful.

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: 'Mark your claimed task as failed.' The verb 'mark' and resource 'task' are specific, and the description distinguishes it from task_unclaim by stating when to use each. It also mentions that the harness now owns this functionality, adding context. However, it doesn't explicitly contrast with all sibling task tools like task_complete, so it loses a point.

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 explicit guidance on when to use: 'Use when you cannot complete it.' It also explicitly contrasts with task_unclaim: 'If you're stepping away but the task isn't truly failed, use task_unclaim() instead.' This is a clear when-to-use and when-not-to-use, naming the alternative tool.

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 already declare readOnlyHint=true and destructiveHint=false, and the description redundantly states 'Read-only, no side effects'—which adds no new value. However, it does add behavioral context beyond annotations: it specifies that the tool returns the full description, expected outcome, and complete history of status changes and comments, and it discloses the short-prefix resolution behavior. This is meaningful and earns a 4.

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 compact, with two clear sentences and an Args listing. The purpose and usage are front-loaded, and every sentence adds value. The Args section repeats the schema but is minimal and unobtrusive. 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 is a simple single-parameter get operation and an output schema exists (indicated by 'Has output schema: true'), the description fully covers usage, purpose, and parameter resolution. It doesn't describe the return format, but that's covered by the output schema. The only minor gap is the lack of an explicit exclusion clause, but overall it's complete for this tool's complexity.

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

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

Schema description coverage is 100%: the schema's task_id description exactly matches the Args text in the description. The description does not add any extra meaning beyond what the schema already documents. Per the rubric, a baseline of 3 applies when schema coverage is high and the description adds nothing new.

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 a specific verb ('Fetch full details of a task by ID') and resource, and further clarifies it includes a chronological comment log. It clearly distinguishes from task_list by stating that task_get is used when an ID is already available. This is unambiguous and differentiates it from the many sibling task tools.

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

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

It gives explicit when-to-use instructions: 'Use when task_list() gave you an ID and you need the description...' This provides clear context. It does not explicitly state when not to use it, but the implicit contrast with task_list and the read-only nature effectively guide selection. No alternatives are named directly, but the context is strong enough for a 4.

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 already cover read-only and non-destructive behavior. The description adds the deprecation status and explains the unblocked filter semantics, which goes beyond the schema. It does not describe return format, but output schema exists to cover that.

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 front-loaded with the deprecation notice and a clear one-line purpose, followed by usage guidance and parameters. It is slightly verbose with the coordination primitive paragraph, but structured and informative without being excessive.

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 annotations, output schema, and 100% parameter coverage, the description fully equips an agent to use the tool correctly. It explains the deprecation, usage context, and filtering options, leaving no critical gaps.

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

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

Schema coverage is 100%, and the description repeats the parameter descriptions verbatim without adding new meaning. The 'unblocked' explanation is identical to the schema, so no extra value is provided 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 'List tasks' and explains it as the coordination primitive for multi-agent work, distinguishing it from task_get (single task) and task_create. The deprecation notice adds clarity about its current role, 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?

Explicitly states when to use (check for open tasks before creating new ones) and when not to use ('not where new work should go' due to deprecation). It also provides specific filter recommendations (status='open', unblocked=True) and explains the context of task coordination.

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 already indicate idempotent and non-destructive behavior. The description adds no further behavioral context beyond the schema, which is acceptable but provides no additional 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?

The description is very concise: a single clear sentence followed by parameter details. No wasted words, and the main purpose is 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?

For a simple removal tool with complete schema and annotations, the description is adequate. The presence of an output schema further reduces the need to describe return values, making the description sufficiently 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 coverage is 100%, so the description's parameter explanations ('The blocked task' for task_id) do not add significant meaning beyond what the schema already provides. 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 clearly states 'Remove a dependency between two tasks,' using a specific verb and resource. It distinguishes from the sibling tool 'task_add_dependency' which performs the opposite 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 does not provide explicit guidance on when to use this tool versus alternatives (e.g., task_add_dependency) or mention any prerequisites. Usage is implied by the purpose, but no direct context is given.

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

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

Annotations only provide destructiveHint=false and openWorldHint=false. The description adds meaningful context: the side effect of writing a body to the task's comment log and the state transition to 'open'. It also discloses the permission constraint. This enriches the safety profile beyond what annotations alone convey.

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 tight and front-loaded: purpose first, then usage context, then args. No unnecessary words. The Args section is clearly separated, and every sentence 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?

The tool is simple (2 params, output schema present) and the description covers purpose, usage scenarios, precondition, and side effects. Nothing an agent needs to invoke it correctly is missing; the output schema handles return value 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 coverage is 100%, so the schema already documents both parameters. The description adds semantic value by clarifying that task_id must be a claimed task and by strongly recommending the body for context handoff, which goes beyond simple type definitions.

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 action ('Release your claim on a task') and its effect ('returns it to open so others can pick it up'). It clearly differentiates from sibling actions like task_claim, task_complete, and task_fail by specifying the unclaiming action and the resulting state.

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 states when to use: 'when you're stepping away mid-flight and the task isn't done or failed', with concrete examples. Also provides a precondition ('Only the agent that claimed it can unclaim it'), which guides correct invocation and implicitly indicates when not to use (if done/failed, use other 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?

Annotations already declare idempotentHint=true and destructiveHint=false. The description adds behavioral context about the 'append' parameter preserving history and permission notes ('Any project member can update tags'), going beyond the annotations to clarify non-destructive behavior and access control.

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 clear first sentence followed by bullet-style parameter details. It is not overly verbose, though the 'Args:' section repeats schema info. It could be slightly more concise, but overall it is efficient.

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

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

Given the existence of an output schema (not shown) and annotations covering safety, the description provides sufficient use-case context and permission details (tags). It does not explain return values or errors, but these are covered by the output schema. The description is reasonably complete for a straightforward update tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description mostly repeats the schema's parameter descriptions (e.g., 'Omit to leave unchanged'), adding no significant new meaning. The explanation of 'append' is slightly more verbose but still largely redundant.

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 'Update a task's description, title, priority, project, or tags' with specific fields, and provides use cases like recording progress notes, correcting metadata, or transferring to a different project. This distinguishes it from siblings like task_comment and task_complete.

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 when-to-use examples (record progress notes, correct metadata, transfer project) but does not explicitly mention when not to use it or suggest alternatives like task_comment for adding comments. It provides some context but lacks exclusions.

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