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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description further clarifies 'Read-only, no parameters, no side effects' plus the auth gate. It adds meaningful behavioral context beyond the structured annotations, particularly the authentication requirement.

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

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

The description is concise, front-loaded with the core action and return value, then covers usage, exclusions, behavior, and auth in a compact space. Every sentence adds useful information 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?

For a zero-parameter, read-only retrieval tool with an output schema, the description fully covers purpose, usage conditions, exclusions, side-effect profile, and auth. 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?

The tool has zero parameters, and the description explicitly confirms 'no parameters'. With an empty input schema, there is little semantic burden to carry, and the description handles it cleanly.

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: 'Return this process's A2A Agent Card JSON (name, skills, endpoints)'. It also names what the tool is not for and explicitly distinguishes it from discover_capabilities and skills_list, so an agent can immediately tell it apart from siblings.

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

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

It gives an explicit condition for use ('Use when another agent needs the card') and an explicit exclusion with named alternatives ('Do not use to list MCP tools or skills — that is discover_capabilities or skills_list'). This fully routes the agent to the correct 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, idempotentHint, and destructiveHint, so the description carries a lighter burden. It adds useful context beyond annotations: 'This tool does not issue new claims', 'Auth: gate', and the TRACE-style provenance detail. 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 compact, front-loaded with the primary function, and each sentence serves a distinct purpose: functionality, use case, exclusion/alternative, read-only clarification, and parameter semantics. 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 single parameter with full schema documentation, rich annotations covering safety/idempotence, and the presence of an output schema, the description covers everything an agent needs: what it returns, when to use it, what not to use it for, auth requirements, and parameter behavior. 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% and the schema already fully documents 'limit' including its maximum-count semantics, ordering, and default. The description simply repeats 'limit is max claims, newest first (default 10)' without adding new information, so it stays at the baseline.

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 ('Return') and resource ('recent attestation claims issued by this kernel'), and even characterizes the claim structure (TRACE-style provenance: tool, allow/deny, risk tier, evidence mode). It explicitly separates this tool from audit_recent, so the agent can distinguish 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?

It provides an explicit positive use case ('Use to verify a prior sandbox/TEE decision') and an explicit negative case with a named alternative ('Do not use for the policy/audit trail — that is audit_recent'). This leaves no ambiguity about 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 cover read-only and idempotent behavior; the description adds valuable context beyond them: the auth requirement ('tool policy gate'), the Decision-System-of-Record scope, and the newest-first ordering. 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?

Every sentence earns its place: purpose, context, exclusion of siblings, read-only safety, parameter note, and auth. The most important scoping information is front-loaded, and there is no filler.

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

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

Given a single optional parameter, rich annotations, an output schema, and clear sibling guidance, the description provides everything an agent needs to select and invoke the tool correctly. Nothing important 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 single limit parameter is already well documented in the schema with default and meaning. The description only restates 'limit caps the list (default 20)', adding no semantic detail beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Return') with a clear resource ('newest Decision-System-of-Record audit events') and lists the event fields. The 'newest first' ordering and explicit contrast with sibling tools make the purpose unmistakable.

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 explicitly states when to use the tool ('inspect what the kernel just decided') and when not to use it for attestation evidence or cache metrics, naming the alternatives attestation_recent and cache_stats. 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?

Annotations already cover read-only, idempotent, and non-destructive. The description adds useful behavioral context beyond annotations: "in-process" reveals the cache is ephemeral and process-local, and "Auth: tool policy gate" discloses an authorization prerequisite. It does not contradict any annotation.

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, purposeful sentences. The first sentence leads with the function, the second provides guidance, and the third covers safety/auth. Every sentence earns its place with 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 simple zero-parameter read-only tool with an output schema and comprehensive annotations, the description is fully complete. It covers purpose, usage, exclusions, auth, and safety. No essential information for invoking the tool 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?

With zero parameters and 100% schema coverage, the schema is trivially complete. The description reinforces this with "no parameters," so no additional parameter semantics are needed. Baseline 4 for zero-parameter tools is appropriate.

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

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

The description states a specific verb and resource: "Return entry counts and hit totals for the in-process result/plan cache." It names the sibling tools it is not (plan_cache_get, memory_read), which clearly differentiates it from alternatives in the sibling 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?

It explicitly says "Use for diagnostics" and "Do not use to read a plan (plan_cache_get) or memory (memory_read)." This provides both the intended context and explicit exclusions, leaving no ambiguity about when to call 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, idempotentHint, and destructiveHint, so the description's 'Read-only and idempotent' reinforces rather than adds. However, it adds non-annotation context with 'Auth: gate', which is important operational behavior for an agent to know before invoking 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 compact and well-structured: core purpose first, then usage timing, exclusions, and safety/auth flags. Every sentence contributes essential information with no filler or redundant elaboration.

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 fully covers when to use it, what it lists, what it does not do, and the auth requirement. There are no meaningful gaps that would prevent 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 query parameter is fully described as an optional case-insensitive substring filter on name or kind. The description only restates 'optionally filtered by a substring query' and does not add new parameter-level meaning, 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?

The first sentence states a specific verb ('List') and resource ('this kernel's MCP tools and loaded Agent Skills'), making the core function immediately clear. It also distinguishes itself from closely related siblings by explicitly naming a2a_card and skills_list, so an agent can select it 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?

The description explicitly says when to use it ('at session start or when unsure which tool to call') and when not to use it ('Do not use to fetch the A2A interoperability card' or 'skill bodies'), naming the alternatives. This is clear, actionable routing 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 already provide readOnlyHint, idempotentHint, and destructiveHint, and the description builds on this by adding behavioral details not in annotations: no network I/O, no quota side effects beyond the tool gate, and the exact return shape (message plus server name/version). This is exactly the kind of added context that helps the agent reason about side effects.

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, no wasted words. Purpose, usage, exclusions, safety traits, and default behavior are all covered in a compact, front-loaded structure.

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-optional-parameter tool with rich annotations and an output schema, the description is fully sufficient. There is nothing an agent needs to know to call it correctly that is missing: behavior, output, side effects, default, and alternatives are all addressed.

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 fully documents the message parameter, including its default value and behavior ('Payload echoed back unchanged'). The description repeats the default but adds no new parameter-specific meaning beyond what the schema already conveys.

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: 'Return the provided message plus server name/version to confirm the MCP session is alive.' It also explicitly differentiates from sibling tools by positioning itself as a liveness probe rather than a discovery or persistence tool.

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

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

The description explicitly says when to use it ('Use as a liveness probe') and when not to use it ('Do not use to discover tools (discover_capabilities) or to persist state'). It names an alternative and provides clear exclusion 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 mark it as mutating (readOnlyHint=false) and non-idempotent (idempotentHint=false), and the description reinforces this with concrete consequences: re-running creates additional summaries and source nodes remain. It also discloses the auth requirement ('tool policy gate'), adding useful operational context beyond the schema and 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 compact and front-loaded: the core action comes first, followed by usage context, an explicit non-delete caveat, and behavioral side effects. Every sentence earns its place with no filler or repetition of schema details.

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

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

For a single-parameter tool with an output schema and clear annotations, the description covers the core action, appropriate trigger, re-run side effects, non-destructive nature, and auth gate. There are no significant gaps 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?

The input schema fully documents from_level with type, title, default and description (100% coverage). The tool description references from_level but adds no parameter-specific detail beyond the schema, 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?

The description uses a specific verb, 'Promote', names the resource ('high-importance nodes with importance >= 0.8') and the destination ('new semantic summary nodes'), and specifies the source level. This clearly differentiates it from sibling memory_write, memory_read, and memory_delete 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 a concrete trigger: 'Use after a burst of memory_write calls to compress working memory.' It also states an explicit exclusion: 'Do not use as a delete — source nodes remain.' It does not name memory_delete as the alternative, but the when/when-not guidance is otherwise strong.

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

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

Even though annotations already mark this as destructive and idempotent, the description adds concrete behavioral detail: it deletes incident edges and entity index rows, missing ids return deleted=false, auth is policy-gated and may require HITL. This gives an agent a clear picture of side effects and failure behavior beyond the annotation flags.

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 four sentences with no filler. The core effect is front-loaded, followed by usage guidance, exclusions, idempotent behavior, missing-id semantics, and auth considerations. Every sentence earns its place and the structure supports quick comprehension by an agent.

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

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

For a destructive, idempotent delete operation with a single well-documented parameter and an output schema, this description is complete. It covers what gets deleted, what does not happen, behavior on missing ids, confirmation guidance, and auth requirements — nothing essential is left to inference.

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% — item_id is already documented as 'Id of the memory node to delete (from memory_write or memory_read).' The tool description does not add meaningful parameter-level meaning beyond what the schema provides, so the 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 opens with 'Permanently delete one memory node and its incident edges/entity index rows,' which states a specific action, resource, and scope. It clearly differentiates from siblings like memory_write, memory_read, and memory_consolidate, and the title 'Delete a memory node' reinforces the purpose.

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

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

The description explicitly says when to use it ('Use when a fact must be forgotten'), what not to do with it ('Do not use to hide a node while keeping it — there is no soft-delete'), and gives a recommended preceding action ('Prefer memory_read first to confirm the id'). This is model guidance for tool selection and safe invocation.

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, idempotent, and non-destructive behavior. The description adds valuable context beyond annotations: the auth gate requirement and the return shape ('scored items plus neighbor ids'). 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?

Three tight sentences with no filler: purpose first, then routing guidance, then safety/return/auth context. 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 7 optional parameters, an output schema, and complete annotations, the description adds the missing auth context and a concise return-shape summary. An agent has enough information to invoke the tool correctly and route around the main alternative.

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 each parameter thoroughly. The description restates the filter dimensions and retrieval modes but adds little semantic detail beyond what the schema provides; the query-vs-item_id exclusion is already in the schema.

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

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

Opens with a specific verb and resource ('Retrieve memory nodes'), names the retrieval modes (embedding similarity, exact item_id), and lists the optional filters. It clearly distinguishes this read tool from memory_write/memory_delete and explicitly separates it from plan_cache_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?

Gives an explicit use case ('Use to recall stored facts') and names the alternative for reusable plan templates ('plan_cache_get') with a direct exclusion ('Do not use...'). An agent can route to the correct tool without inspecting sibling definitions.

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, idempotentHint, and destructiveHint. The description adds useful context beyond those by stating 'Read-only, idempotent, no parameters' and 'Auth: tool policy gate', giving the agent operational expectations not present in the structured fields.

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

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

The description is three short sentences with no filler: capability first, then use case, then exclusion and alternative. Every sentence earns its place, and the most important distinguishing information 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?

With an output schema present, no parameters, and annotations covering safety and idempotency, the description provides all remaining operational context: when to use, when not to use, and authentication expectations. Nothing material 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?

There are zero parameters, so the schema fully covers the input surface and the description correctly confirms 'no parameters.' With no parameters to document, a baseline of 4 is appropriate here.

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

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

The description states a specific verb ('Return'), a precise resource ('node counts by level plus edge and entity-index sizes'), and explicitly names the sibling it is not (memory_read). An agent can unambiguously distinguish this from memory_read, memory_write, and cache_stats 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?

It says exactly when to use the tool ('capacity/health checks') and explicitly says when not to use it ('Do not use to read node content'), naming the alternative (memory_read). The no-parameters note also removes any ambiguity about invocation.

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?

Even though annotations already mark readOnly=false and idempotent=false, the description adds 'Mutating and not idempotent: each call creates a new item_id', 'Gated by plan quota', and the consolidation threshold for importance >= 0.8. It also discloses auth via tool policy gate and no network I/O, going beyond what annotations 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 dense but every sentence adds information: operation, use case, exclusion, idempotency, quota, importance threshold, and auth/network behavior. It is front-loaded with the core action and there is no redundant padding.

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 mutation tool with 8 parameters and an output schema, the description covers purpose, use vs alternatives, side effects, quotas, auth, and downstream consolidation behavior. Nothing an agent needs to decide whether and how to call it is left out.

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 adds value by framing entities and causal_parent as 'edges' and by explaining that importance >= 0.8 nodes are later promoted by memory_consolidate, which gives parameters behavioral meaning beyond their 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?

Description opens with a specific verb+resource: 'Insert one node into the multi-graph memory store' and clarifies the memory types (episodic/semantic/procedural) and optional edges. It distinguishes itself from siblings by explicitly not being plan_cache_put and by context of remembering facts/decisions/session 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?

States exactly when to use ('Use to remember facts, decisions, or session state the host should own') and when not to ('Do not use for reusable task plans'), naming plan_cache_put as the alternative. This gives an agent an unambiguous selection rule.

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 and idempotentHint annotations, the description reveals concrete runtime behavior: missing keys return deleted=false. It also discloses an auth requirement ('tool policy gate') and clarifies the deletion is scoped to the exact plan-cache entry. These details meaningfully exceed annotation-only information.

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?

Every sentence carries distinct value: purpose, usage trigger, sibling exclusion, behavioral semantics, and auth. The most important identifying information is front-loaded, and there is no filler or repetition.

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 destructive tool with complete annotations and an output schema, the description covers usage, edge-case behavior (missing key), and access control. Nothing essential is missing for an agent to decide whether and how to invoke it.

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

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

Schema description coverage is 100%, with the parameter already documented as the exact key previously passed to plan_cache_put. The description reinforces this by saying 'exact plan-cache entry for task_description,' but adds no new format, constraints, or semantic details beyond what the schema 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 identifies the action ('Delete the exact plan-cache entry'), the target resource ('plan-cache entry for task_description'), and the exact key semantics. It also distinguishes itself from memory_delete, which prevents confusion among 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?

The description explicitly states when to use the tool ('Use to drop a stale template') and names the alternative for a different use case ('Does not delete memory nodes (that is memory_delete)'). This gives an agent clear routing guidance without needing to inspect sibling schemas.

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 readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable behavior beyond those: it specifies the return contents ('found, similarity score, and plan'), the default similarity threshold (0.68), and the auth requirement ('tool policy gate'). 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?

Five short sentences, each carrying distinct information: purpose, positive usage, exclusions, read-only nature, return shape, threshold, and auth. No filler; the most important behavior 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 single-parameter read-only lookup tool with a rich output schema, the description covers the essential operational context: when to use, what it returns, the default threshold, and auth. 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 description coverage is 100%, so the baseline is 3. The description only restates that the lookup is keyed by task_description, which the schema already says. It does not add new parameter-level detail such as length limits, example formats, or accepted wording.

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 ('Semantic lookup'), a resource ('a previously stored plan template'), and the key mechanism ('keyed by task_description'). It clearly distinguishes this from memory_read and plan_cache_put by naming them, so the agent can tell the tools apart immediately.

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?

Explicit usage guidance is provided: 'Use to reuse a multi-step plan' and 'Do not use to recall facts from memory (memory_read) or to write a plan (plan_cache_put).' This names both when to use and when not to use, with direct sibling references.

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 mutation, but the description adds key behavioral context: 'same task_description overwrites the exact key' and 'Auth: tool policy gate'. This goes beyond the structured hints and clarifies the overwrite side effect, though the auth note is somewhat vague.

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

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

Three concise sentences, each earning its place: purpose, usage guidance, and behavioral/auth note. The most important information 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?

With two fully documented parameters, an output schema, and annotations, the description supplies all necessary extra context: when to use, when not to use, overwrite semantics, and auth awareness. Nothing critical is missing 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%, so the schema already documents both parameters. The description reinforces the role of task_description as the lookup key but does not add substantial parameter-level detail 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 verb (store), the resource (structured plan template), and the keying mechanism (by task_description) for later semantic reuse. This differentiates it from siblings like plan_cache_get, plan_cache_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 explicitly says 'Use after you have a working plan' and 'Do not use for episodic facts (memory_write)', naming the alternative tool and giving an exclusion condition. This leaves no ambiguity about when the tool should be selected.

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 annotations, the description discloses that only loaded skills are listed, that skill markdown bodies are not returned, and that authentication is gated by tool policy. It also explicitly states 'Read-only', consistent with the readOnlyHint annotation.

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 and front-loads the primary purpose, then adds usage guidance, exclusions, and auth in a logical sequence. Every sentence earns its place without repetition.

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 listing tool with an output schema, the description fully covers what the tool returns, how to use it, what it does not return, and how to get the missing content. 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?

This tool has zero parameters, so the schema already fully covers the parameter surface. The description appropriately adds no parameter information, matching the baseline of 4 for parameterless tools.

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 loaded Agent Skills') and identifies the exact fields returned: name, skills:// URI, description, and tags. It clearly distinguishes itself from the sibling a2a_card tool and from fetching skill markdown bodies.

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 explicitly says when to use the tool ('Use to find skill resources to read next'), what it does not do ('Does not return skill markdown bodies'), and names the alternative ('fetch those via the skills://{name} resource'). It also warns against using it for the A2A card, leaving no ambiguity.

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 adds substantial behavioral detail beyond the annotations: it clarifies that the operation 'does not kill an external worker process', only updates kernel state, is 'destructive relative to the handle', is 'idempotent if already cancelled', and that missing ids 'return cancelled=false'. This is exactly the kind of nuance an agent needs and is not present in the annotations or 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 description is compact and every sentence adds relevant information: purpose, use case, side-effect scope, destructiveness, idempotency, failure behavior, suggested prerequisite, and auth. The primary purpose is front-loaded in the first sentence, and no sentences are wasted.

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 cancellation tool with rich annotations and an output schema, the description is complete. It covers the operation's semantic effect, non-effects, idempotency, missing-id behavior, authentication, and relationship to tasks_get. An agent has enough information to use this tool correctly without further investigation.

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 only parameter, task_id, has a clear description in the schema. The tool description adds no new parameter-level meaning; the missing-id behavior is a return-value concern rather than parameter semantics. Baseline 3 is appropriate since the schema carries the parameter documentation burden.

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 'Mark a task cancelled', a specific verb and resource that clearly identifies the tool's function. It further distinguishes the tool from siblings by framing its use case as 'stop polling a handle you no longer need', which separates cancellation from get/update/list operations.

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 clear context for when to use the tool: 'Use to stop polling a handle you no longer need.' It also gives sequencing guidance with 'Prefer tasks_get first.' It does not explicitly name alternatives or list when-not-to-use cases, but the context is sufficiently clear for an agent to decide.

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 annotations, the description discloses that the task is initially pending, durability depends on the sqlite tasks backend being enabled, ttl_ms is only an expiry hint, and auth requires a tool policy gate plus plan quota. This is meaningful behavioral context beyond readOnly/idempotent flags.

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 and front-loaded: the core purpose appears first, followed by usage guidance, exclusions, behavioral traits, and auth. Every sentence earns its place and there is no 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?

With an output schema present and full parameter descriptions, the tool description covers the essential operational context: what it creates, durability caveats, how to interact with the result, what not to use it for, and auth requirements. No critical gaps remain.

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 all three parameters at 100% coverage, so the baseline is 3. The description adds value by clarifying that ttl_ms is a handle expiry hint rather than a strict guarantee, which is not fully captured by the schema's 'suggested time-to-live' phrasing.

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 and resource: 'Create a durable async task handle (pending)'. It also distinguishes the tool from siblings by explicitly saying it starts long-running work polled with tasks_get or tasks_list, and by excluding memory_write and plan_cache_put.

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?

Usage guidance is explicit: use it for long-running work you will poll with tasks_get or list with tasks_list, and do not use it for storing facts or plans. The auth note adds another practical precondition, making the selection criteria very 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, idempotentHint, and destructiveHint, and the description adds further behavioral context: missing ids return task_not_found, and auth is via tool policy gate. It also clarifies the return payload contents (status, progress, result, error), which are not in 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?

Three tightly packed sentences with zero redundancy. The main purpose is front-loaded, usage guidance follows, and behavioral details are summarized at the end. Every clause adds distinct 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 single-parameter read-only tool, the description fully covers what an agent needs: how to call it, when to use it, what it returns, what happens for missing ids, and the auth requirement. The annotations cover safety and idempotency; no output schema is needed because the payload content is described.

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, task_id, already has a clear schema description ('Task id returned by tasks_create / tasks_list'). The tool description adds little beyond using the same term, so the schema carries the semantic load. Baseline 3 applies since schema coverage is high.

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 ('Fetch one task handle by task_id') and names exactly what the handle contains (status, progress, result, error). It explicitly differentiates from sibling tools tasks_stats and tasks_list, so an agent can immediately distinguish it.

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 when-to-use ('poll after tasks_create') and when-not-to-use ('Do not use for aggregate counts — that is tasks_stats — or to list many tasks (tasks_list)'). It names the alternatives directly, leaving nothing 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, idempotentHint, and destructiveHint, which the description reinforces. The description adds valuable context beyond annotations: the ordering behavior ('newest updated first'), the auth requirement ('tool policy gate'), and the intended recovery use case. 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?

Every sentence earns its place: core behavior, usage intent, exclusions, safety characteristics, and auth. Information is front-loaded and there is no repetition 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 simple two-parameter list tool with full schema coverage, an output schema, and rich annotations, the description covers all necessary guidance: purpose, ordering, auth, safety profile, and when not to use it. 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%, so the schema fully documents both parameters. The description adds a mention of 'filtered by status' but does not add new semantic detail beyond what the schema provides. Baseline 3 is appropriate given full schema coverage.

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

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

States a specific verb ('List'), resource ('task handles'), ordering ('newest updated first'), and filtering ('by status'). It clearly distinguishes from the sibling tasks_get by naming it explicitly in the usage guidance.

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 context ('recover ids after restart') and explicit when-not-to-use exclusions ('Do not use to poll a known id (tasks_get) or to mutate state'). This is exactly the guidance an agent needs to select correctly among siblings.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description reinforces these traits while adding auth context ('Auth: tool policy gate'). This is useful behavioral information beyond the structured annotations, even though it does not describe response shape.

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 and front-loaded: the core return value appears first, followed by usage guidance, exclusions, and annotations-related traits. Every sentence contributes distinct information with no 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 parameterless, read-only statistics tool with an output schema and clear annotations, the description covers purpose, usage, alternatives, safety, idempotency, auth, and absence of parameters. Nothing essential is missing for an agent to select and 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?

The tool has zero parameters and the schema is empty, so the baseline is 4. The description explicitly confirms 'no parameters,' which adds no new meaning but is consistent and reassuring for the agent.

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 resource (task store), the action (return total task count and counts by status), and distinguishes itself from tasks_get and tasks_list. The purpose is concrete and an agent can tell it apart from sibling tools without inspecting 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?

Explicitly says 'Use for dashboards' and warns against using it to read a specific handle (tasks_get) or list handles (tasks_list). This gives both positive and negative usage guidance with named 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 discloses mutation semantics ('Mutating; last write wins'), error behavior ('Missing ids return task_not_found'), and authorization context ('Auth: tool policy gate'). These add real behavioral context beyond the annotations, which already mark this as non-read-only and non-idempotent.

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 sentences, each carrying distinct value: what it patches, when to use it, what not to use it for, and key behavioral caveats. No filler, no repeated schema text, and the most important info 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 mutating update tool, the description covers usage timing, exclusions, mutation semantics, error cases, and auth. The output schema exists, so return-value explanation is unnecessary. Sibling-tool disambiguation is already handled, making this complete for an agent to select and 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 description coverage is 100%, so the schema already documents all parameters. The description names the relevant fields but adds no new semantic detail beyond what the schema 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 uses a specific verb ('Patch') with a clear resource ('an existing task') and enumerates the exact fields affected: status, progress, message, result, error. It also explicitly differentiates from sibling tools by saying what it is not for (cancel via tasks_cancel, create via tasks_create).

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 an explicit usage context ('Use while a worker is running') and names the alternatives to avoid ('Do not use to cancel — that is tasks_cancel — or to create a new handle (tasks_create)'). This is strong, unambiguous routing guidance.

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