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 doesn't say whether this is a read-only listing, whether it mutates anything, whether pagination applies, what the ordering is, or what the response contains. Only the terse enumeration of categories is given.

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 tight sentence with no padding, and the purpose is front-loaded. The list of qualifying states is dense but each word earns its place by defining the filter.

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 zero annotation coverage, a 0%-documented schema, and no output schema, the description leaves too much unresolved: nothing on mutability, scope semantics, result format, or how results should be acted on. An agent can guess the intent but not invoke it reliably.

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% and the two parameters (limit, scope) are undocumented anywhere. The description explains nothing about what 'scope' means for this tool or how limit interacts with the result set, leaving the agent to guess the valid scope values despite the sibling tools implying workspace/source scoping.

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) and resource (memories) plus the qualifying states it targets: expired, superseded, invalidated, conflicted, need review. That distinguishes it from recall (general retrieval) and review_changes, though it doesn't explicitly name a sibling as the alternative.

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 enumeration of problem states implies when the tool is applicable, but there is no explicit instruction on when to prefer it over recall or review_changes, nor any prerequisites or exclusions. Usage is inferable but not guided.

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 disclosure. It says what facets are explained but not whether this is read-only, what the output looks like, or whether lineage resolution is expensive. For a diagnostic tool with zero annotation coverage, this is thin.

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, front-loaded sentence with no filler. Efficient, though it reads as a feature list rather than a usable definition.

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

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

For a no-annotation, no-output-schema tool with an undocumented id, the description omits return format, read/write nature, and any cost or permission context. An agent can guess the purpose but not the contract.

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?

Only one parameter (id) and schema description coverage is 0%, so the description should ideally clarify what the id refers to. It doesn't — the word 'memory' is the only hint. Baseline for a single trivial param is not particularly low, but the 0% coverage leaves the id format unexplained.

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?

State a specific verb (Explain) and resource (a memory), listing the facets returned: state, history, dependencies, dependents, and replacement lineage. It is distinguishable from siblings like recall or audit_memory, though it doesn't explicitly say how it differs from 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?

No guidance on when to use this rather than recall or audit_memory, both of which sound adjacent. The description implies diagnostic usage but provides no conditions or 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?

With no annotations, the description carries full burden, and it does disclose two real behavioral traits: history is preserved (non-destructive) and dependents are flagged for review. It omits anything about permissions, idempotency, or what the operation returns, so the disclosure is partial rather than rich.

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

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

Two short sentences with no filler, and the key constraint (non-destructive) is front-loaded before the side effect on dependents. 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?

This is a mutation tool with no annotations, no output schema, and 0% parameter coverage, so the description is the only source of information. It is too thin: it omits permission requirements, reversibility of the invalidation, and the meaning of both inputs.

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 for undocumented parameters, and it does not. It never explains what 'id' identifies or what role the optional 'reason' plays, leaving both parameters semantically bare.

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 ('Mark a memory invalid') and adds a meaningful scope qualifier ('without deleting its history'). It does not differentiate from the closest sibling, 'supersede', which is conceptually adjacent and would leave an agent guessing which to pick.

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 hints at a downstream review flow ('Dependents will require review') but gives no explicit when-to-use guidance or when to prefer 'supersede' or 'review_changes' instead. An agent must infer the selection criteria entirely.

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 burden. It usefully discloses that results default to current, non-conflicted memories and that stale items are reported as warnings, which adds behavioral context. Yet it omits whether the operation is read-only, permission requirements, rate limits, or pagination behavior, leaving significant 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?

Two sentences with no filler, and the core behavior is front-loaded. Every sentence earns its place by stating the action and the default result handling.

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 search tool with four parameters, no annotations, and no output schema, the description is too thin. It does not explain scope, limit, query syntax, or return shape, and it lacks any guidance on handling warnings or stale items beyond the default 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. It only indirectly explains include_stale via the default filtering behavior and implies a search query, but says nothing about limit, scope, or the format of query. This is insufficient for a tool with four undocumented 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 states a clear verb and resource: 'Search memory.' This distinguishes it from siblings like remember, supersede, and invalidate, which are write or lifecycle operations. However, it does not explicitly name or contrast with any sibling, so it falls short of 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?

The description gives no guidance on when to use this tool versus alternatives such as explain_memory, audit_memory, or review_changes. It only implies usage through the word 'Search' and default filtering behavior, with no exclusions or 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?

No annotations are provided, so the description carries the full behavioral burden. It says memories are 'durable' and include 'freshness metadata,' but does not explain persistence semantics, conflict handling (though the schema mentions key conflicts), required permissions, or what happens on write. This is insufficient disclosure for a mutation tool with no 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 a single front-loaded sentence with no wasted words. However, for a 12-parameter mutation tool, such extreme brevity leaves the structure underpowered even if it is technically concise.

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 12 parameters, no annotations, no output schema, and only 8% schema description coverage, the description is far too sparse. It states the tool's broad purpose but omits parameter meanings, usage context, and behavioral details needed to call it correctly.

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

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

There are 12 parameters with only 8% schema description coverage, so the description must compensate heavily. It merely echoes the 'type' enum values and vaguely gestures at 'freshness metadata'; it does not explain key, tags, scope, source, metadata, confidence, depends_on, expires_at, valid_from, or review_after.

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 ('Store') and resource ('durable fact, assumption, decision...') and enumerates the memory types, making the core action clear. It does not explicitly distinguish itself from siblings such as supersede, invalidate, recall, or track_source, so sibling differentiation is absent.

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 no when-to-use or when-not-to-use guidance. It does not mention alternatives like recall, supersede, or invalidate, nor does it state prerequisites or preferred contexts for storing a new durable memory.

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 burden. It does disclose a non-obvious conditional requirement (a reviewed replacement statement is needed for text changes on accept), which is real behavioral value, but it says nothing about reversibility of dismiss/accept, permissions, or downstream 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?

Two tight sentences with the core action first and the conditional constraint second. No filler, no repetition of the tool name.

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 no annotations, no output schema, and fully undocumented parameters, the definition is thin: it omits what happens to the change after resolving, whether the action is reversible, and what the caller should expect back. The one useful conditional is not enough.

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% across 4 parameters. The description maps the accept/dismiss choice to the 'action' parameter and hints at 'statement' for text changes, but 'change_id' and especially 'reason' are never explained in either place, so it does not compensate for the coverage 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?

States a specific verb+resource pair (resolve/accept-or-dismiss a source change), which is clearer than the sibling names review_changes or sync_sources. It does not explicitly distinguish itself from review_changes, which presumably surfaces the same pending changes, so it stops short of full sibling differentiation.

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 implied by 'pending source change' and the accept/dismiss pair, and one conditional rule is given ('Text changes require a reviewed replacement statement when accepted'). However, no alternatives are named and no precondition is stated (e.g., that the change must first be surfaced via review_changes).

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 verb 'List' implies a read-only operation, and identifying changes 'waiting for review' conveys the filter state. With no annotations, however, the description does not disclose permission requirements, pagination behavior, or scoping semantics.

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 a single, front-loaded sentence with no filler. Its brevity is efficient, though it borders on being too sparse rather than richly concise.

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 no annotations, no output schema, and 0% schema description coverage, the description omits critical context such as what 'scope' accepts and whether results are paginated. It is not complete enough for an agent to invoke the tool confidently.

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 0% description coverage for both parameters, and the description does not mention 'limit' or 'scope' at all. Neither the allowed values for 'scope' nor the pagination role of 'limit' is explained anywhere.

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 ('List') and resource ('source changes waiting for human or agent review'), and the state filter clarifies the purpose. It does not distinguish the tool from related siblings such as resolve_source_change or sync_sources, so it stops short of 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?

There is no explicit when-to-use guidance, no mention of alternatives, and no prerequisites or exclusions. Usage is only implied by the tool name and the phrase 'waiting for human or agent review'.

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 it does disclose two non-obvious behaviors: history is preserved and dependents of the old memory are flagged for review. However, it omits whether the old memory becomes inactive, how the dependents are surfaced, and any permission or irreversibility notes for a 14-parameter mutation.

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

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

Two short sentences, front-loaded with the action and its key benefit, with zero filler. It is well formed; brevity is only a minor issue here because the underlying gaps are semantic, not stylistic.

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?

A 14-parameter mutation tool with no annotations, no output schema, and no parameter documentation needs far more than two sentences. The description covers the concept but leaves the mechanics of the call largely unspecified.

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% across 14 parameters, and the description mentions none of them. old_id, statement, reason, confidence, scope, depends_on and the rest of the fields are left entirely unexplained, so the description cannot compensate for the coverage 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?

States a specific verb ('Replace') on a specific resource ('a memory') plus the distinguishing behavioral trait of preserving history. That separates it from a plain overwrite, though it never names the sibling it competes with (e.g. invalidate or remember) to make the distinction explicit.

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 no when-to-use guidance and doesn't route to alternatives. An agent facing 'update a memory' has to guess whether to use supersede, invalidate, or remember; the only hint is the downstream note that dependents need review, which implies a scenario but not a decision 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?

With no annotations, the description carries the full burden, and it does disclose one genuinely valuable behavioral trait: auto-mode changes replace memory while review-mode changes become pending. However, it omits whether this requires permissions, whether it mutates state immediately, and any rate/scope limits on the check.

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

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

Two tight sentences with the core action front-loaded and the mode behavior second; no filler. The second clause is dense and slightly cryptic, but nothing is 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 mutating-in-spirit sync tool with no annotations, no output schema, and two fully undocumented parameters, the description covers the mode semantics but is thin on parameters and on what the check returns. Adequate but clearly incomplete.

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 both parameters (due_only, source_id) are undocumented anywhere. The description's word 'now' faintly implies an immediate versus scheduled check, but it never explains due_only or what source_id scopes, leaving the primary parameter ambiguity unaddressed.

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 ('Check tracked local sources now') on a specific resource, but 'sync' implies write-back while 'check' suggests only inspection, leaving the actual operation ambiguous. It does gesture at the sibling ecosystem via 'auto-mode' vs 'review-mode' but never names a sibling, so an agent cannot cleanly separate it from track_source or review_changes.

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 explicit when-to-use guidance or exclusion relative to the many siblings (track_source, review_changes, resolve_source_change, watch_status). The mode distinction hints at context but never says when an agent should call this versus resolving changes or checking watch_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?

No annotations are provided, so the description carries the full burden. It hints at a stateful linkage ('establish its current value as the baseline') but says nothing about side effects, whether monitoring/polling occurs, permissions required, or what happens on re-tracking an already-tracked memory. The 'baseline' phrase is the only real behavioral signal.

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 front-loaded sentence with no filler, and the core action leads. It is efficient but terse to the point of under-specification for a 7-parameter tool.

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

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

For a 7-parameter tool with no annotations, no output schema, and low schema coverage, one sentence is insufficient. An agent lacks enough to invoke this confidently relative to its source-tracking siblings.

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 29% (selector and statement_template documented, the rest bare). The description gestures at 'JSON or text file' (mapping to the kind enum) but does not explain mode, interval_seconds, or the interaction between kind and path. It fails to compensate for the low 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 and resource: 'Link an active memory to a local JSON or text file' with the added scope of establishing a baseline. An agent can grasp what the tool does, but the description never distinguishes it from closely related siblings like sync_sources, watch_status, or resolve_source_change.

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 when-to-use guidance, no preconditions beyond the vague phrase 'an active memory', and no routing to alternatives. Given a sibling family that includes sync_sources, watch_status, and resolve_source_change, this omission leaves the agent to guess which source-tracking tool to pick.

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 burden. It does disclose the categories of information returned (health, overdue checks, errors, pending changes), which is real value given there is no output schema, but it never states that the call is non-mutating, what permissions are needed, or any pagination/rate constraints.

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 front-loaded sentence with no filler. Its brevity is efficient, though the terseness borders on under-specification rather than genuinely earned concision.

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 no annotations, no output schema, and an undocumented parameter, the description is the only carrier of information and it falls short. Listing the reported categories helps, but the scope parameter and the read-only nature of the call remain unexplained.

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 single 'scope' parameter has 0% schema description coverage and is never mentioned in the description. Nothing tells the agent what values scope accepts or what happens when it is omitted (it is not required). Almost no meaning is added beyond the bare 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?

States a specific verb ('Show') and enumerates the resource contents it reports: tracked source health, overdue checks, errors, and pending changes. An agent can tell this is a read-oriented status/monitoring tool. It does not, however, explicitly differentiate itself from nearby siblings like review_changes, sync_sources, or audit_memory.

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?

No when-to-use statement, no prerequisites, and no named alternatives among the ten sibling tools. Use is only implied by the word 'Show' and the notion of tracked sources; an agent must infer the trigger condition.

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