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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal a key behavior: 'With no refs given, everything this session touched is pinned.' This adds context beyond the schema. However, it does not state whether the tool persists data, requires permissions, or has any side effects, leaving some behavioral gaps for a write-oriented 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 exactly two sentences, front-loaded with the primary action ('Write a handoff packet') and then elaborating with specifics. Every sentence contributes meaningful information without repetition or fluff.

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

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

Given the tool's moderate complexity (6 parameters, no output schema, no annotations), the description provides a solid high-level understanding: what the handoff packet contains and the default behavior when refs are omitted. It does not describe return values or side effects, but for a simple handoff tool this is a reasonable level of completeness.

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

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

Schema description coverage is only 33% (summary and to_agent have descriptions). The tool description compensates somewhat by referencing 'what was done, what is left, what is still unclear' and 'exact record versions,' which map to summary, next_steps, open_questions, and refs. However, it does not directly explain each parameter's syntax or constraints, and the mapping is implicit rather than explicit.

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

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

The description clearly states the tool's function with a specific verb ('Write') and resource ('handoff packet'), and enumerates the packet's contents: what was done, what is left, what is unclear, and exact record versions. This distinguishes it from sibling memory/recall tools, which focus on past interactions rather than forward-looking 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?

The description gives clear context: it is for writing a handoff packet for the next agent. It does not explicitly mention alternatives or exclusions, but the 'next agent' framing makes the intended use case unambiguous. A 5 would require explicit when-not-to-use guidance, which is absent.

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 readOnlyHint:true, the annotation already signals safety. The description adds meaningful behavioral detail: the result is ordered oldest first, includes authorship/confidence metadata, and describes the hash chain linking versions. This goes beyond the annotation and gives the agent an accurate model of the tool's output 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 a single, tightly packed sentence that front-loads the most important idea ('Every version of one key, oldest first') and then adds specific useful detail. No wasted words; every clause 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?

While the tool has only two parameters and no output schema, the description still leaves a critical gap: 'scope' is undefined. The return contents are described in terms of metadata and hash chain, but no structure is given, and the parameter semantics are incomplete. For an agent to invoke this tool correctly, it needs more context on what 'scope' represents.

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 has zero description coverage, so the description must explain both parameters. It refers to 'one key' but never clarifies the 'scope' parameter, which is required. The meaning of 'scope' remains ambiguous from both schema and description, leaving the agent without enough information to correctly construct parameters.

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

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

The description clearly states the tool provides every version of a specified key, ordered oldest first, and lists the included details (author, timestamp, confidence, hash chain). It is not a tautology and effectively distinguishes itself from sibling tools like 'remember' and 'recall' by focusing on version history, though it lacks an explicit verb like 'get' or '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 implies when to use the tool: when you need to see the full version history of a key, including metadata. However, it provides no explicit guidance on when not to use it, no mention of alternatives like 'recall', and no exclusions, so usage context is only inferred rather than stated.

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, confirming no destructive side effects. The description adds valuable behavioral context beyond annotations, such as the specific computations it performs (counts, average confidence, handoff states) and the integrity check of the hash chain. This informs the agent about the tool's analytical nature and potential complexity (e.g., re-walking hashes).

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

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

The description is a single sentence that efficiently lists the tool's capabilities without redundant words. It is front-loaded with the main action ('counts') and covers all key outputs. However, the list-like structure could be slightly more readable (e.g., separating distinct items with commas or formatting), but it remains concise and informative.

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 one optional parameter, no output schema, and a read-only annotation, the description adequately conveys what the tool returns (counts, averages, states, integrity check result). It does not explicitly state the return format or confirm that it returns a summary object, but the implied items give sufficient context for an agent to understand the output nature.

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% for the single optional parameter 'verify', which already explains its meaning ('Also re-walk every hash'). The description does not add any additional parameter semantics beyond what the schema provides, 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 clearly states the tool's purpose with a specific verb ('counts') and lists the exact resources and metrics it covers: per agent and scope, average confidence, handoff states, and an integrity check. This distinguishes it well from sibling tools like 'remember' and 'recall' which are about recording or retrieving memories, not summarizing statistics.

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 this tool is used for obtaining aggregate statistics and performing integrity checks, but it does not explicitly state when to use it versus alternatives (e.g., 'history' for chronological sequences, 'handoff' for state transitions). No exclusions or prerequisites are mentioned, so the guidance is only 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?

Annotations provide readOnlyHint: true, so the read-only nature is already covered. The description adds context by specifying 'current version' and 'current records', indicating it returns latest state, not historical. It doesn't mention pagination but for a read tool with annotation, this is adequate.

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

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

The description is a single concise sentence that covers the dual functionality without fluff. It's front-loaded with the main action 'Read' and then enumerates search criteria efficiently.

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 it's a read-only tool with readOnlyHint already in annotations, the description covers key behaviors: exact key retrieval, search modes, and what is searched (scope, tag, free text, min confidence). It doesn't mention limit parameter in description, but schema covers min/max. For a tool of this complexity, it's adequately 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?

Description explains key (scope+key), scope prefix, tag, free text, and minimum confidence, giving meaning to params like tag, query, scope, and min_confidence that have no schema description. Limit is not mentioned, but overall it compensates for the 50% 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?

The description clearly states the tool's function: reading a specific key or searching current records. It distinguishes between exact key lookup and search modes, and differentiates from siblings like remember (write) and history (past versions).

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 explains the two usage modes (exact key vs search) but does not explicitly contrast with alternatives like history for past versions or memory_stats. There's implied guidance by showing search parameters, but no explicit 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It mentions 'confidence moves' and 'audit trail', which suggests mutation, but does not state whether the action is reversible, what happens on conflicting outcomes, or any rate limits or permissions required. This is insufficient for a tool with 5 parameters.

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

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

The description is two sentences with clear, imperative language and front-loaded purpose. It efficiently covers outcome, audit, and handoff without excess. Could be slightly more structured but is mostly effective.

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

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

Given no output schema, the description should explain return values or confirmation behavior, which it does not. With 5 parameters including nested objects, it omits details on how 'refs' defaults work and what the audit trail returns. Adequate but not complete for complex interactions.

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 40%, and the description adds value by explaining 'outcome_ref' as an external reference and mentioning 'handoff_id' for closing packets. However, it does not clarify defaults for 'refs' or constraints like 'version' minimum beyond schema. Baseline adjusted for partial 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?

The description clearly states the tool reports success or failure against records, using verbs like 'report' and 'close the loop'. It distinguishes from siblings like 'remember' (likely creation) and 'history' (likely retrieval) by emphasizing outcome tracking and audit trails.

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 use when finalizing a decision, but does not explicitly state when not to use it or suggest alternatives among siblings like 'handoff' or 'resume'. It mentions passing 'handoff_id' but no exclusions or prerequisites.

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?

Since annotations only state readOnlyHint=false and idempotentHint=false, the description adds critical behavioral context by disclosing that writing an existing key appends a new version rather than overwriting, ensuring no data loss. It also implies that the tool mutates state (non-read-only) consistent with annotations. It does not mention potential side effects like storage limits or the need for specific permissions, but the key versioning behavior is well covered.

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

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

The description is a single, clear sentence that is front-loaded with the purpose ('Store a fact') and then efficiently conveys the critical behavioral nuance about versioning. No wasted words, ideal length for an agent to parse quickly.

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

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

The tool has 5 parameters, 2 required, and no output schema, so the description needs to cover mutation behavior and parameter usage. It does so adequately by explaining the versioning behavior and clarifying the scope+key structure. However, it does not specify return values or any potential errors, but with no output schema and high schema coverage, the description is reasonably complete 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?

The schema has 100% coverage, with descriptions for all parameters (e.g., 'Name inside the scope' for key, 'Labels for later filtering' for tags). The description adds meaning by framing the parameters as 'scope+key' and explaining that value can be any JSON, but it does not go beyond schema for individual parameters. Since schema coverage is high, the baseline is 3, but the description's emphasis on the scope+key pairing and the versioning behavior adds practical semantics that elevate it slightly.

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 'Store a fact under scope+key', using a specific verb (store) and resource (fact with scope and key). It distinguishes from siblings like 'recall' (which presumably retrieves) and 'history' (which shows versions). The mention of versioning behavior further differentiates it from a simple write 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 explains when to use this tool (to store facts) and implicitly when not (it appends rather than overwrites, so users must be aware). It does not explicitly name alternative tools like 'recall' for retrieval, but the context signals include sibling tools that suggest the use case. The versioning guideline helps clarify a key decision point for the agent.

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

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

No annotations are provided, so the description must carry full behavioral transparency. It discloses that refs with moved versions are reported as stale rather than silently swapped, which is a valuable behavioral detail. However, it does not disclose whether claiming is idempotent, whether it removes the packet from the queue, or what happens if the handoff_id is invalid. A 3 is appropriate because while it adds some behavior context, significant gaps remain for a mutation-like 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 extremely concise, using two sentences to convey purpose, usage nuance, and a critical behavioral quirk (stale refs). No waste, front-loaded with the key action. The behavioral detail is earned 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?

Given the tool's action (claiming a packet, likely a mutation) with no annotations, output schema, or parameter descriptions, the description is reasonably complete for its complexity but falls short. It explains the core behavior and a trick (stale refs), but omits return format details, error cases (e.g., no open packets), and whether claiming is mutable or reads the state. For a single-param tool with no output schema, a 3 reflects adequate but not robust completeness.

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

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

Schema description coverage is 0%, meaning the description must compensate. The description implies handoff_id is optional ('or a specific one by id') and suggests default behavior is to claim the oldest open packet. However, it does not document the handoff_id parameter's format, semantics, or constraints. Given the low coverage and single parameter, this is a notable gap.

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 'Claim' and clearly identifies the resource as 'the oldest open packet addressed to this agent (or a specific one by id)' and states the return of both the packet and pinned records. It distinguishes from siblings like 'handoff' (likely a related tool) and 'remember'/'recall' by emphasizing a claim/retrieve action on open packets.

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 clarifies when to use this tool: to claim an open packet addressed to the agent, with an optional specific id. It implicitly excludes use for packets not addressed to the agent or not open. However, it does not explicitly state when not to use it (e.g., if the agent already has a claimed packet) or provide explicit alternatives among siblings.

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