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

Adds real behavioral context beyond the annotations: no network request, no automatic log/file collection, and a mandatory preview-and-approval gate, which softens the readOnlyHint=false mutation signal. It never says what the non-read-only action actually produces (a draft file, a held payload), so the side-effect profile is incomplete.

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

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

Four short sentences, front-loaded with the purpose followed by scope, safety and routing constraints. No filler and nothing repeated from the 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?

For a 7-parameter tool with no output schema and no parameter descriptions, the description should explain which fields matter for which report kind and what the 'prepared' result looks like. It covers scope and safety well but leaves those 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?

Zero schema description coverage across 7 parameters, and the description only gestures at the kind enum via 'bug report, feature request or help request'. It gives no guidance on when the optional steps/actual/expected/environment fields are required per kind, leaving the agent to guess.

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 (Prepare) plus the exact artifact types (bug report, feature request, help request) and the target repo (al-mighty/localmcp). The verb 'prepare' plus the later 'before publishing' distinguishes it from the feedback_submit sibling without ambiguity.

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

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

Explicit inclusion criterion (only when the user wants to report a LocalMCP problem or suggestion), explicit workflow requirement (show the full preview and ask for approval before publishing), and an explicit exclusion with an alternative route (vulnerabilities/credentials go to SECURITY.md, not public issues).

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?

Goes well beyond the annotations by disclosing draft TTL (15 minutes), process ownership, the returned issue URL, and the no-auto-retry policy — none of which the hints convey. There is mild tension with idempotentHint=true, since the description warns against retrying uncertain results, which limits the practical value of that hint; a reader could be confused about whether a retry is safe.

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?

Dense and front-loaded: the approval precondition arrives in sentence two, before any operational caveats. Slight redundancy between 'never submit automatically after an error' and 'do not automatically retry uncertain results' keeps it off a perfect score.

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 two-parameter mutation with no output schema, the description supplies the return value, the safety precondition, the draft lifecycle (15-minute expiry, process-scoped), and the failure-handling policy. Nothing an agent needs to call it correctly is missing apart from parameter mapping.

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 description compensates only indirectly by referencing the feedback_prepare draft. It never explains that draft_id is the UUID returned by feedback_prepare, nor that confirmation must be the literal string 'publish' — the most likely source of a malformed call.

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 ('Publish a feedback_prepare draft') and names the sibling tool that produces the input, making the prepare/publish pairing unambiguous. Adds the auth context ('under the user's existing gh login') which no structured field carries.

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

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

Explicitly states the precondition ('Call only after explicit user approval of that draft's repository, title and body') and two hard exclusions ('Never submit automatically after an error' and 'do not automatically retry uncertain results'). An agent knows exactly when it may and may not invoke this tool.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is structured. The description still adds real value by stating the removal is permanent and by constraining the legitimate deletion cases, though it says nothing about whether the record is recoverable or whether a confirmation/lookup step is expected.

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, zero filler, with the permanence warning and the primary use case front-loaded before the alternative routing. 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?

For a one-parameter destructive tool with annotations carrying the safety profile and no output schema, the description covers purpose, permanence, and the sibling split. Only the identifier semantics and post-delete recoverability are left unaddressed.

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 description never mentions the single parameter. The agent must infer from the bare property name 'id' (uuid) that it identifies the memory to delete — obvious in practice, but the description compensates for none of the coverage gap on a destructive call.

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 ('Permanently remove a memory') and immediately scopes it against a named sibling. An agent can distinguish it from memory_supersede or memory_update 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?

Gives an explicit when-to-use ('entries that were wrong to record at all: secrets, noise, mistakes') and an explicit when-not with the alternative named ('For facts that merely became stale, use memory_supersede'). This is exactly the routing guidance a destructive tool needs.

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?

readOnlyHint=true already declares the safety profile, so the description's job is supplementary — and it does add real value by disclosing the return granularity (full text vs. search excerpt). It omits behavior for a missing/invalid id (error vs. empty result), which for a mutation-free read is a modest gap.

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, verb-and-resource first, alternative second. No filler and no restatement of the title.

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

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

For a single-param read tool with no output schema, the description covers the essential unknowns: what comes back (the whole text) and when to prefer it over search. Only not-found/error semantics are unaddressed.

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%, but the schema itself constrains id tightly (uuid format plus an explicit pattern), so the agent knows the expected shape. The description only says "by id" and adds no hint about where to obtain it or whether missing ids error out, 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 and resource ("Fetch one memory in full by id") with unambiguous scope — single record, full content. It also names the sibling memory_search and distinguishes the two by what each returns (excerpt vs. whole text).

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

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

Explicitly states the selection condition: call this "when the excerpt is not enough and you need the whole text," contrasting with memory_search. That is a concrete when-to-use rule plus the alternative, not just implied 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?

readOnlyHint=true already establishes this is a safe read operation. The description adds the query-free browse behavior, but does not disclose ordering, default limit, whether superseded memories appear by default, or the shape of returned results.

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, front-loaded with the core capability and immediately followed by use cases. No filler; every phrase contributes to selection or invocation.

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

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

For a read-only list tool with five optional parameters and no output schema, the description makes the basic call clear. However, it omits how include_superseded works, whether results are paginated or ordered, and what a returned memory entry looks like, leaving meaningful 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 description coverage is only 20%, with only 'project' documented. The description merely names project/kind/tags and leaves 'include_superseded' and 'limit' unexplained; 'include_superseded' in particular is an important filter whose default behavior is unclear, so the description 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 action (Browse/List) and resource (memories), names three filter dimensions, and distinguishes itself from query-based retrieval by saying 'without a query.' It does not explicitly name memory_search as the alternative, 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?

Gives two concrete use cases: auditing stored memories and loading a project's context at session start. It also implies the alternative path by contrasting with query-based browsing, though no explicit when-not or prerequisite is 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?

The readOnlyHint annotation already establishes safety, and the description adds useful context about retrieval mode (semantic + lexical) and trustworthiness ('source of truth'). However, it says nothing about result ordering, relevance/threshold behavior, or how many results come back by default, which matter for interpretation of a search tool with no output schema.

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

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

Two sentences, no filler, with the capability stated first and the usage directive second. Every clause carries actionable information.

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 six-parameter read tool with no output schema, the description covers purpose, scope, and when to invoke. The remaining gap is what results look like and how they're ranked, but with a limit parameter and high schema coverage this is a minor omission rather than a blocker.

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 83% and the description mentions no parameters at all; the schema already documents kind, tags, project, include_superseded, and query with examples. Baseline 3 applies since the description adds nothing beyond structured fields here.

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

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

States a specific verb and resource ('Hybrid semantic + lexical search over persistent cross-project memory') and adds the scope qualifier 'cross-project', which cleanly separates it from memory_get and memory_list. An agent knows immediately what kind of retrieval this is.

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

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

Gives an explicit trigger ('Call this BEFORE answering questions about past decisions, incidents, infrastructure quirks, or user preferences') plus a boundary condition ('not derivable from the current repo'). It stops short of naming alternatives such as memory_get for known IDs or memory_list for enumeration, so the routing guidance is clear but not exhaustive.

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, so the safety profile is covered. The description adds real context beyond that: this is a lightweight reachability/health probe with zero parameters and no mutation, which tells the agent it can call it cheaply as a pre-flight 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 sentences, both load-bearing: the first defines the output, the second the use case. Front-loaded and free of filler.

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

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

For a no-parameter, read-only tool with no output schema, the description supplies exactly the missing pieces: what the counts are grouped by (project, kind) and that health/embedder status is included. Nothing an agent needs to call it correctly is absent.

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. Baseline of 4 applies; the description correctly avoids inventing parameter semantics that don't exist.

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 concrete verb and result set: 'Counts per project and kind, plus embedder and database health.' An agent can tell immediately that this is a diagnostic/aggregate tool, distinct from the record-level siblings like memory_get, memory_list, and memory_search.

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

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

'Use to verify the store is reachable and to see what knowledge exists before searching blindly' gives clear when-to-use conditions and implicitly points at memory_search as the alternative that shouldn't be invoked blindly. It stops short of an explicit when-not or a named alternative tool, so not a full 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?

Annotations already declare readOnlyHint=false and destructiveHint=false, so the description's real job is the retention semantics, and it delivers: the old record remains queryable. It still omits whether the new memory receives a new id, what the call returns, and what happens when the referenced id doesn't exist.

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, zero filler, with the action first and the selection preference second. Every clause carries information the agent needs.

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

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

The retention model is covered, but this is an 8-parameter mutation with 5 required fields, 13% schema coverage, and no output schema telling the agent what to expect back. The identity of the new record, optional-field behavior, and failure modes are left unaddressed.

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 13% of the 8 parameters have schema descriptions, so the description must carry meaning — and it does not. It never clarifies the critical split between the old record's id and the new memory's fields (title, body, kind, project), nor what happens to omitted optional fields like tags, source, or importance.

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 ("Replace an outdated memory with a new one") plus the distinguishing behavior: the old version survives and stays queryable. That contrast with plain deletion makes it immediately separable from memory_delete and memory_update without opening a 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?

Explicit routing rule: "Prefer this over delete whenever a fact changed" — a clear when-to-use with a named alternative. It never addresses memory_update, the closest sibling, leaving the update-vs-supersede choice to inference.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, and 'in place' is consistent with that non-destructive profile, so no contradiction. However the description never states the key behavioral question for an update tool: whether omitted fields are preserved (patch) or cleared, and whether the original revision is retained. With annotations covering the safety profile, the bar is lower, but this is a meaningful gap.

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 zero waste; the core purpose is front-loaded and the alternative follows immediately. Nothing could be cut without losing a routing decision.

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?

Purpose and sibling routing are fully covered, but with no output schema and 0% schema description coverage, the definition leaves an agent unable to predict update semantics (partial vs full replacement) or parameter meaning. Adequate for selection, thin for correct invocation.

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

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

Schema description coverage is 0% across 6 parameters, so the description carries the full burden and provides nothing: no mention of id being the required key, no indication that body/title/tags/source/importance are optional partial updates, no note on importance's 1-5 range or tag replacement semantics. This is a clear miss for a 6-param tool.

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 ('Amend an existing memory in place') and immediately distinguishes itself from the sibling memory_supersede. An agent can tell which of the two mutation tools to reach for without opening either 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?

Explicitly gives the selection rule: corrections/additions that don't change the memory's subject use this tool, while a changed belief routes to memory_supersede. Both the when and the alternative are named.

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?

Goes well beyond the annotations by disclosing the de-duplication contract: near-duplicates are rejected and the existing id is returned, which is non-obvious write behavior an agent must anticipate. It stops short of stating what a successful write returns or how the write interacts with later memory_search, so it is strong but not exhaustive.

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

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

Four sentences, all load-bearing: purpose first, then the taxonomy, then the exclusion rule, then the duplicate-handling consequence. No restatement of the name or title and no filler.

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

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

For an 8-parameter write tool with no output schema, the description covers the highest-risk ambiguity (what belongs here, what happens on duplicates) and the schema carries the rest. Minor gap: the `force` override is documented only in the schema, so the agent must combine both sources to understand bypassing the duplicate check.

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 75%, and the description compensates by giving each `kind` enum value a concrete meaning tied to a real situation, which the bare enum list in the schema does not. It does not explain `force`, `importance`, or `tags` beyond what the schema already says, so it adds meaning but not for every parameter.

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

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

"Persist one durable fact" is a precise verb+resource, and the following sentence enumerates exactly which classes of knowledge qualify (incident, decision, fact, preference, reference, snippet). This makes it immediately distinguishable from memory_update, memory_supersede, and memory_search among the siblings.

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

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

Explicit when-to-use list, an explicit negative rule ("Do NOT store what the repo or git history already records"), and explicit routing to alternatives when a near-duplicate is rejected ("update or supersede that instead"). Both the inclusion and exclusion criteria are stated, not inferred.

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