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

With no annotations, the description carries the full burden and delivers the two most important write semantics: "Overwrites what it states, merges files," which tells the agent exactly what is replaced versus appended. It does not cover error behavior, size/rate limits, or whether the checkpoint requires an open investigation, so a few behavioral gaps remain.

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 the write-mode and purpose, then the field enumeration, then the call-timing directive. Every clause adds usable information given zero schema coverage, 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?

An output schema exists, so return-value explanation is rightly omitted, and the description covers purpose, timing, and field intent for a seven-parameter write tool. Missing pieces are secondary: precondition (does an investigation need to be open?) and failure/overwrite-conflict behavior.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it explains that decisions are "each with a one-line reason," that blockers are optional, and that in_progress should carry the investigation id. It still leaves the expected format of files entries and done granularity implicit across seven 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 opens with an explicit mode marker ("WRITE") and a specific verb+resource: saving the session's working state so it survives context compaction. Enumerating the captured state (goal, done, in_progress, next, decisions, files, blockers) makes it clearly distinguishable from read-oriented siblings like session_state and memory_status.

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 concrete triggers: "Call after every completed subtask and before any long operation," plus a field-level convention to reference the open investigation id in in_progress. It stops short of naming alternatives explicitly (e.g., "read with session_state") or stating when not to checkpoint, so it is strong but not complete 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?

With no annotations, the description carries the full burden and does well: the "WRITE" tag flags mutation, "soft-delete" clarifies data is not destroyed, and "restorable with the CLI" gives the recovery route along with a user-consent precondition. It omits edge behavior such as what happens when a prefix matches more than one memory, so it is not fully complete.

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 clauses with the mutation flag front-loaded, then the action, then the precondition. Nothing repeats and 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?

An output schema exists, so return values need no explanation, and the description covers action, scope, recoverability, and consent. The only material gap for a destructive-by-intent tool is prefix-collision behavior, which is left to be discovered at call time.

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

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

Schema coverage is 0% and the single `id` parameter has no description at all, so the description must compensate; "by id or unique id prefix" does add real meaning over a bare string type. It leaves the ambiguity handling for non-unique prefixes unaddressed, which is the one semantic gap an agent would want.

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 the specific verb and resource ("Soft-delete a memory") plus the accepted identifier forms, so it is immediately distinguishable from read-side siblings like search_memories or memory_status. It stops short of naming a sibling alternative explicitly (e.g., when to use store_memory vs this), which keeps it from a 5.

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?

"Precondition: the user asked to forget it" gives one explicit gating condition for invocation, which is more than most tools offer. It implies the recovery path ("restorable with the CLI") but never states the negative case, such as not using it for a memory the user merely wants hidden, so it is not a full when/when-not pair.

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

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

With no annotations, the description carries the full burden and does well: it flags the tool as a WRITE and discloses the concrete side effect that status=solved creates one pitfall memory pointing at the closed investigation while abandoned creates none. It omits what happens if no investigation is open, whether closing is reversible, and whether any other status values are accepted.

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?

One dense sentence, front-loaded with the 'WRITE.' classification and the core action. Every clause carries information, though wording like 'pointing at it' is slightly compressed and costs a moment of 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?

An output schema exists, so return values need not be explained, and the description covers the critical mutation side effect. It falls short on edge cases: behavior when no investigation is open, irreversibility of the close, and the full valid value set for status.

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

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

Schema description coverage is 0%, so the description must compensate. It valuably explains the status parameter's semantics and reveals two valid values ('solved', 'abandoned') plus the default, but says nothing about the required root_cause and fix beyond naming them – no expected format, length, or content guidance.

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 (close the open investigation) and names the required inputs (root_cause, fix). It is clearly distinguishable from the siblings investigation_open, investigation_log, and investigation_status, and the leading 'WRITE.' marker immediately separates it from the read-style memory/session 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 phrase 'the open investigation' implies the prerequisite that an investigation must be open, which is useful context. However, it never names an alternative or states when an agent should close with 'solved' vs 'abandoned' – the choice is left entirely to inference.

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

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

With no annotations, the description carries the full behavioral burden and does substantial work: it declares write semantics, the ordering discipline (command logged BEFORE execution, result afterward), the default anchor, and the one-entry-per-experiment invariant. It omits what happens if no investigation is open and whether entries can be amended or removed.

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 the operation type and tightly written; nearly every clause carries a distinct rule. The telegraphic shorthand 'HEAD(+.config)' and the compressed kind list border on cryptic, which costs it a point on clarity despite the efficiency.

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?

Output schema exists, so return values need no explanation, and the description covers the mutation workflow, entry taxonomy, and sequencing rules well for a 6-parameter write tool with no annotations. The unaddressed `refs` parameter and undefined failure behavior (no open investigation) are the remaining 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 0%, so the description must compensate. It defines `kind`'s valid values, explains `command` and `result` including their enumeration (good/bad/inconclusive), and gives `anchor`'s default. However, `refs` — an opaque anyOf array of free-form objects — is never mentioned, and `text` is left implicit.

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 'WRITE. Append to the open investigation.' — a specific verb, resource, and scope (the *open* investigation) that separates it from read-oriented siblings like investigation_status and from the lifecycle siblings investigation_open/close. An agent can tell immediately this creates log entries rather than reading or closing an investigation.

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 strong conditional guidance: which `kind` values exist, that `ruled_out` requires a one-line reason, and that an experiment needs `command` logged before running with `result` recorded after. It also forbids batching ('one entry per experiment, never a summary of several'). It does not name sibling alternatives (checkpoint, store_memory, investigation_status), so it stops short of 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?

Since no annotations were provided, the description carries the full burden of behavioral context. It successfully discloses that the system operates on a single instance ('one open at a time') and details the core behavior: 'Snapshots the project's environment memories.' This is crucial behavioral data.

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 definition is highly front-loaded, starting with a clear instruction ('WRITE') followed by the resource action. The subsequent sentences clearly expand on the use-case and side effects without unnecessary 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 absence of annotations and the lack of structured parameter documentation, this description is exceptionally complete. It defines the constraint (one open at a time), the required inputs (title/symptom), and the nature of the secondary input (env).

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 0% schema description coverage, the description must define everything. It gives specific meaning to each parameter, explaining that 'env' 'adds free-form setup text,' thereby clarifying the role of the three parameters beyond their technical types.

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 purpose is clearly stated: 'Open a debug investigation for the current project.' It identifies the resource and the action. While it doesn't explicitly list all siblings, framing it as an investigation distinguishes it from generic memory storage or 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?

It provides strong 'when to use' guidelines, stating it should be used 'before the first experiment when a task is debugging.' This clearly scopes the intended workflow and helps the AI distinguish it from other routine data logging calls.

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

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

With no annotations, the leading "READ." is valuable — it explicitly declares the operation is non-mutating. It also discloses the compact/paged nature of the payload and that it should be re-read after compaction (implying possible staleness). However it says nothing about behavior when no investigation is open or when an unknown `id` is supplied (error vs. empty payload), which is the main undisclosed trait.

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 the operation type, then the returned contents, then the call triggers. Dense and waste-free, with no restatement of the tool name or schema.

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 no explanation, and one optional parameter keeps the surface small. What's missing for a state-reset tool is the failure/empty case and any note that the snapshot is a summary rather than the full log.

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

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

Schema coverage is 0% — `id` is a bare nullable string with no description. The description's "(or `id`)" does add real meaning: default resolves to the currently open investigation, and `id` overrides that to fetch some other one. That is useful but doesn't say whether closed/archived investigations are addressable or what format the id takes.

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 read of the open investigation's state and enumerates exactly what it returns (symptom, setup, ruled out, hypotheses, experiments, blocker, commands not to re-run). That enumeration separates it from investigation_log and checkpoint, though it never names a sibling explicitly.

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 two concrete trigger conditions: at the start of any debugging task and after every compaction. There is no statement of when not to use it and no named alternative (e.g. investigation_log or session_state), so it stops short of full 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?

With no annotations, the description carries the burden and does so: it declares read-only semantics ('READ'), states there are no preconditions, and discloses notable side-behaviors of the output (marking the current project and clone). It doesn't mention cost, limits, or ordering, which keeps it short of a 5.

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 the READ qualifier, then a compact inventory of returned fields; every clause carries information. The parenthetical field list is dense but earns its place by describing the response shape.

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 needn't be fully specified, and the description still summarizes them plus safety and precondition state. A zero-param read tool is adequately covered; only the absence of any comparison to sibling listing tools is a gap.

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

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

The tool takes zero parameters, so there is nothing to disambiguate and the baseline of 4 applies. The description correctly implies a full unfiltered listing with no inputs.

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 and resource ('All projects') and enumerates the payload (memory counts, identities, checkouts with path/branch/head/label, current project and clone marks). An agent can tell this is the project-enumeration tool versus memory-oriented siblings like search_memories or list_recent, though it doesn't name them explicitly.

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?

'READ' plus 'No preconditions' signals it is always safe to call and requires no setup. However, it never says when to prefer this over alternatives such as list_recent or investigation_status, so the routing decision is only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that this is a read operation, that results are newest-first, the retrieval scope, and that candidates are excluded. It does not explain limit behavior, pagination, or permissions, leaving meaningful behavioral 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 short and front-loads the key operation with "READ." It is dense but mostly earned, though the parenthetical scope phrasing is telegraphic and slightly hard 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?

For a simple one-parameter read tool with an output schema, the description covers ordering, scope, and candidate exclusion. It still omits limit semantics and any sibling routing guidance, leaving clear but not severe 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?

There is one parameter, limit, with 0% schema description coverage, and the description never mentions it or explains its meaning. The parameter name is somewhat self-explanatory, but the description adds no semantics beyond the bare 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 states a specific read operation and identifies the resource as memories, with ordering "Newest memories first." It also clarifies scope: current project, linked projects, global, and all projects outside a project. It does not explicitly name or differentiate itself from siblings such as search_memories, so it stops short of 5.

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 is only implied by "READ" and "Newest memories first"; there is no explicit when-to-use or when-not-to-use guidance. The description does not point to search_memories or list_projects as alternatives, though the scope and candidate exclusion give some 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?

With no annotations, the description carries the burden itself, and it does disclose the read-only nature ('READ.') and the full set of things inspected. It does not disclose that the Ollama reachability and vector-search checks may involve network/embedding work and therefore carry latency, nor whether any of these checks can fail or degrade the call — a meaningful omission for a probe tool that touches an external service.

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

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

A single compact sentence front-loads the mode ('READ.') then lists the returned dimensions in order of specificity. Every clause names a distinct piece of information; nothing is redundant or padded.

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 and the parameter set is empty, so return-value detail is already covered and the description needn't repeat it. Given that low complexity, the field enumeration plus read-only marker is close to sufficient; the only real gap is the absent cue on when this beats the neighbouring status/session tools.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The description correctly implies a no-argument, whole-system snapshot rather than a targeted query.

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 enumerates exactly what the tool surfaces — DB path, schema version, per-kind counts, FTS health, vector state, Ollama reachability, current project — which unambiguously reads as a system diagnostics/status report. The leading 'READ.' verb-plus-field-list makes the resource clear, though it never explicitly names itself relative to siblings like session_state or investigation_status.

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

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

There is no statement of when to call this versus alternatives, no prerequisites, and no exclusions. An agent must infer from the field list that this is the health/diagnostics probe, with no guidance on whether to reach for it before or instead of session_state or investigation_status.

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

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

With no annotations, the description still discloses key traits: it is a read operation ('READ'), results are capped and never a full dump, and 'Candidates are never returned' clarifies result semantics. Missing are ranking behavior details, whether results span across projects in a defined order, or any auth/permission notes.

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 the operation type front-loaded ('READ'), then scope, then result bounds. The parenthetical 'or `project`, a label or id' is slightly awkward but earns its place by defining the 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?

An output schema exists, so return-value explanation is unnecessary, and the description covers scope, bounded results, and exclusion of candidates. What remains thin is guidance on choosing this tool over list_recent and details on cross-project result ordering, but nothing required 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 0%, so the description must compensate, and it does reasonably: `query` is implied as the search input, `limit` caps the hit count, and `project` is clarified as 'a label or id' including global/linked scope. It does not state the default limit (8) or the query syntax, keeping it short of a 5.

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 (relevance-ranked search) and resource (long-term memories), plus the scope: current project, linked projects, and global memories, with optional override by `project`. It is clearly distinguishable from siblings like list_recent, store_memory, and forget_memory without opening any schema.

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 framing 'Returns at most `limit` hits, never a full dump' implies this is the targeted-search path rather than enumeration, which is useful context. However, no sibling is named and there is no explicit when-to-use/when-not guidance versus tools like list_recent or memory_status, so the agent must infer the choice.

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

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

With no annotations, the description carries the burden and does disclose key traits: this is a read-only operation and it returns an empty object rather than erroring when no checkpoint exists. It does not cover auth or scope, but for a zero-arg read that is minor.

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?

One short sentence with the operation type front-loaded and the empty-result behavior appended. The telegraphic 'READ.' style is slightly clipped but wastes no 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?

An output schema exists, so return shape need not be explained, and there are no parameters to document. For a simple zero-arg read the description is nearly complete; only the relationship to the 'checkpoint' sibling is left implicit.

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 takes no parameters, so the baseline is 4; there is nothing for the description to disambiguate.

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 and resource: reads the current session's checkpoint, including state and its rendering. The leading 'READ.' distinguishes it in spirit from the mutating sibling 'checkpoint', but no sibling is named outright.

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 'READ' framing and the 'or {} when none' clause imply when the tool applies (non-mutating inspection, safe when no checkpoint exists), but there is no explicit guidance on when to prefer 'checkpoint' or other session 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?

With no annotations, the description must carry the behavioral burden. It usefully discloses that this is a WRITE operation and adds the explicit-consent precondition, but it does not describe overwrite/duplicate behavior, persistence guarantees, failure modes, or other side effects an agent might need for a mutation tool.

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

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

The description is front-loaded with the operation and precondition, then uses compact semicolon-separated parameter notes. It is dense but efficient, with no obvious filler; the opaque "§15" reference is the main minor structure issue.

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 an 8-parameter mutation tool with no annotations and 0% schema description coverage, the description covers the core intent, consent precondition, and several important parameters. However, it leaves multiple parameters undocumented and does not explain duplicate handling or lifecycle behavior, so it is only partially 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 description coverage is 0%, so the description must explain parameters. It adds useful meaning for kind, scope, global_memory, and refs, but leaves tags, anchor, project, and content without semantic detail beyond the schema field names.

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: "WRITE. Store one memory." This clearly distinguishes the tool from read-oriented siblings such as search_memories and list_recent, though it does not explicitly name an alternative 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?

It gives a strong precondition: only store when the user explicitly asked or confirmed a proposed fact, and never store silently. That provides clear when-to-use and when-not-to-use guidance, but it does not route the agent to sibling alternatives for adjacent tasks.

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