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

No annotations are provided, so the description carries the burden. It discloses that the ADR is stored as a structured capture and can be recalled by any agent on the same project. However, it does not clarify whether the tool creates a new record each time, whether it overwrites existing records, or any side effects like memory isolation when team_id/task_id are used. The description offers some context but not complete behavioral transparency.

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

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

The description is three sentences, each earning its place: the first names the action, the second provides a usage condition, and the third explains storage and sharing. It is front-loaded and free of redundant wording, making it easy for an agent to parse quickly.

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

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

The tool has a moderate complexity with 11 parameters and 3 required, but the description includes the key context: what the tool does, when to use it, and how the resulting data is used (recallable). It does not explicitly link to related tools like recall or capture, but the phrase 'can be recalled' hints at the ecosystem. The absence of an output schema means no return-value explanation is needed, and the description covers the essential usage scenario.

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

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

Schema description coverage is 100%, so the schema already documents all 11 parameters. The description does not add additional parameter-level meaning beyond what the schema provides. According to the guidelines, a baseline of 3 is appropriate when the schema covers all parameters.

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

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

The description clearly states the tool records an Architecture Decision Record (ADR) with a specific verb ('Record') and resource ('Architecture Decision Record'). It also explains the purpose: 'when you make a technical decision that future agents should know about,' which distinguishes it from generic capture tools.

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

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

The description explicitly tells the agent when to use the tool: 'Use this tool when you make a technical decision that future agents should know about.' It does not mention alternatives or exclusions, but the condition is clear and actionable. The mention that ADRs are 'recalled by any agent' also sets expectations for use.

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 discloses a required environment condition (REMEM_OFFLOAD_ENABLED=true and pipeline=mermaid) and explains the output is a compact symbolic graph rather than full logs. It does not discuss error cases or side effects, but for a read-style get tool this is a reasonable disclosure.

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

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

The description is compact and front-loaded: the core action appears first, followed by what the canvas is, when to use it, and a required precondition. Every sentence earns its place and there is no redundant or filler content.

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 read-only tool with two optional parameters and no output schema, the description explains the purpose, output nature, usage context, and environment prerequisite. It does not explicitly state read-only behavior, auth, or error handling, but these are minor given the 'get' semantics and strong schema coverage.

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

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

Schema description coverage is 100%, and both parameters already have clear descriptions and an enum for format. The tool description adds conceptual context about the canvas but does not add meaningful parameter-level detail beyond the schema. This matches the baseline for high schema coverage.

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

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

The description opens with a specific verb+resource: 'Get the Mermaid task canvas for the current session.' It then explains what the canvas is and how it differs from verbose tool logs, making the tool's identity and value clear. This distinguishes it well from the many sibling knowledge, recall, and skill getters.

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

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

The description explicitly says 'Use this to see the task structure without re-reading full tool outputs,' which gives clear invocation context. It also lists environment prerequisites. It does not name specific alternative tools or state when not to use it, but the usage context is strong enough for selection.

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

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

With no annotations provided, the description carries the full behavioral burden and does so well. It discloses that captures are project-local by default, that secrets are redacted before storage, that messages are flattened for search while originals are retained, and that atoms affect recall behavior. This is substantial beyond the schema.

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

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

The description is compact and front-loaded: it opens with the core purpose, then usage timing, content options, scoping default, and the critical global-memory caveat. Every sentence contributes either behavioral, scoping, or usage information without 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?

For a 17-parameter tool with no output schema and no annotations, the description covers the essential aspects: when to call, what to store, project-local behavior, the global exception, redaction, and the messages/atoms interaction. Remaining gaps are minor—it does not mention output behavior or the isolation parameters (task_id, team_id, user_id, agent_id)—but the schema covers those.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful parameter-level context beyond the schema: the semantics of session_key='global', the content-versus-messages relationship, and the behavior of atoms. This elevates the score, though many parameters like tags, metadata, and verified are left to the schema.

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

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

The description names a specific action ('Store a decision, a learning, or a task outcome to memory') and gives concrete examples of when to call it. It is clear and distinguishes capture from retrieval-oriented siblings like recall and search, but it does not explicitly differentiate from record_outcome or knowledge_create, so it misses the top score.

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

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

The description gives explicit usage timing: call after completing a non-trivial task, making a decision, or fixing a bug with a known root cause. It also gives a strong exclusion—global memory should only be used when the user explicitly asks—and tells the agent exactly how to enable it via session_key='global'. It does not name alternative tools, 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?

With no annotations, the description is the sole source of behavioral information. It discloses the return content ('called functions with file paths and line numbers') and the necessary input. However, it does not mention whether results are direct or transitive callees, how limit affects results, or any potential performance implications. This leaves some ambiguity for a code-analysis 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 two sentences, immediately states the purpose, and front-loads the key information. The second sentence adds essential return-type detail and a prerequisite. Every word earns its place; no 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?

For a simple read-only tool with two parameters and no output schema, the description covers the essential aspects: what it does, what it returns, and what input is required. It does not mention edge cases like pagination or direct vs. transitive callees, but these are not critical for a basic query tool and can be inferred from the schema and tool name.

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 provides a description for symbol_id, and the tool description reinforces this by stating the symbol ID comes from codegraph_search. The limit parameter is not described in the schema or the description, but its name and default/max values make it reasonably self-explanatory. The description adds minimal value beyond the schema for parameter understanding.

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

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

The description clearly states the action ('Find all callees of a symbol') and explains the query in plain language ('what does this function call?'). It distinguishes the tool from its sibling codegraph_callers by explicitly focusing on callees, not callers.

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 a clear usage context: use this when you need to know what functions a given symbol calls. It explicitly states a prerequisite ('Requires the symbol ID from codegraph_search'), which helps the agent know the correct invocation sequence. It does not contrast with alternatives like codegraph_callers, but the purpose is unambiguous enough to guide selection.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It claims to 'Find all callers' but the schema includes a 'limit' parameter with a default of 50 and a maximum of 200, meaning it does not truly return all callers unless explicitly set. This omission is misleading, and the description does not mention any other behavioral traits like read-only status or pagination.

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 brief and front-loaded, starting with an imperative verb and immediately conveying the core purpose. The three sentences each serve a clear role: defining the action, restating in plain language, and providing the necessary prerequisite. No unnecessary words are present.

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 an output schema, the description should fully explain the tool's behavior. It fails to mention the 'limit' parameter's effect, and the claim of 'all callers' conflicts with the capped result size. This leaves an agent unsure about whether the result set is complete or truncated, which is a significant gap for a tool with minimal other documentation.

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 symbol_id parameter is well-described both in the schema and the description, which adds the important note that it comes from codegraph_search. However, the 'limit' parameter is not mentioned in the description, and the schema only provides type/default/maximum without explaining its purpose. With 50% schema coverage, the description partially compensates but leaves the optional parameter ambiguous.

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

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

The description uses a specific verb ('Find') and identifies the resource ('callers of a symbol'), clarifying the function with 'who calls this function?' and specifying the return format (function names with file paths and line numbers). It effectively distinguishes itself from sibling tools like codegraph_callees, which would find the opposite relationship.

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 clearly states a prerequisite ('Requires the symbol ID from codegraph_search'), implying a workflow where users must first search for the symbol. It does not explicitly mention alternatives or when not to use this tool, but the context of sibling tools and the clear use case provide sufficient 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?

No annotations are provided, so the description must convey the tool's behavior. It explicitly describes the internal steps (runs git diff, finds symbols, traces callers) and the return value (affected symbols + risk classification). It does not mention side effects or permissions, but the steps imply a read-only analysis.

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

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

The description is two concise sentences that clearly outline the tool's purpose, method, and output. No redundant or vague language is present.

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 description explains what the tool does, how it works, and what it returns. It does not mention prerequisites (e.g., an existing codegraph index) or potential limitations, but for a tool that returns analysis results, this is sufficient for an agent to decide when to use it.

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

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

The schema already includes descriptions for all three parameters, covering their purpose (isolation, traversal depth, repository path). The description adds no additional meaning beyond what is in the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: detecting uncommitted git changes and mapping them to affected symbols with blast radius. It is distinct from sibling tools like codegraph_impact or codegraph_callers by focusing on uncommitted 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?

The description implies usage context (uncommitted changes) by mentioning 'git diff --name-only' and tracing callers. However, it does not explicitly contrast with alternatives or state when to prefer this tool over codegraph_impact or other impact-analysis tools.

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. It discloses the traversal methodology (upward via callers of callers) and the dependency on codegraph_search. It does not explicitly mention read-only safety or output format, but the analysis nature implies a non-mutating operation.

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 question and then the method. No filler or redundancy.

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 description covers purpose, method, and input provenance. Since there is no output schema, it could be more explicit about the return structure, but the phrase 'find all potentially impacted code' gives a sufficient expectation for selection and 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 covers both parameters at 100%, so baseline is 3. The description adds value by specifying that symbol_id must originate from codegraph_search and by clarifying the upward traversal direction, which aids understanding of max_depth's effect. This goes slightly beyond the schema.

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

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

The description clearly states the tool's purpose: perform impact analysis for a symbol change. It distinguishes itself from siblings like codegraph_callers by explicitly specifying upward traversal ('callers of callers') and requiring a symbol ID from codegraph_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?

It provides a concrete use case ('if I change this symbol, what else might be affected?') and a prerequisite (requires symbol ID from codegraph_search). The traversal direction implies when to prefer this over direct-caller tools, but it does not explicitly name alternatives 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?

No annotations are provided, so the description carries the full burden. It does more than declare a side effect: it identifies the content extracted, supported languages, recursive directory handling implied by the schema, and the auto-index relationship. It does not, however, clarify whether re-indexing replaces existing data or what completion signals are returned.

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

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

The description is two sentences: the first gives the action and resource, the second adds the auto-index note and language coverage. It is front-loaded and contains no redundant filler; the language list and auto-index clarification are relevant, targeted details.

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

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

The description, together with the schema, covers inputs, supported languages, recursive indexing, and the primary usage situation. There is no output schema, and the description does not explicitly state what the tool returns or how the agent will know indexing completed, which is a modest gap. Overall, though, it gives enough context for selection and 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?

Because there is 100% schema description coverage for all parameters, the schema already provides complete meanings. The description does not add meaningful new parameter semantics beyond reinforcing that paths/directions use recursive index behavior. The baseline 3 applies, as no important param context is missing.

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

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

The description uses a specific verb ('Index') with a concrete resource ('a file or directory into the code graph') and explains what is extracted: symbols, call relationships, and imports. It also differentiates the tool from sibling search tools by noting that codegraph_search auto-indexes, so this tool is for explicit re-indexing or custom paths.

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

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

It explicitly states when this tool is needed: 'only need this for explicit re-indexing or custom paths,' and when it is not needed: because 'codegraph_search auto-indexes on first use.' This gives agents a clear 'when to use vs. alternative' guideline.

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 transparency burden. It discloses that results are sorted by line number, but doesn't clarify directory traversal behavior, pagination via limit, or explicitly state read-only guarantees beyond the word 'List'.

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 concise sentences, front-loaded with the action, no filler. 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?

Provides purpose, sorting, and usage hint, but lacks details about the output format (what fields per symbol), limit semantics, and potential errors. Since there is no output schema, this is a notable 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?

Schema covers 75% of params; description adds context that file_path can be a directory and that 'all symbols' are returned by default, reinforcing kind's optionality. It doesn't elaborate on limit or team_id beyond schema, so added value is moderate.

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

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

The description clearly identifies the action (list), the resource (all symbols), and the scope (file or directory). It distinguishes from sibling tools by framing it as an overview tool, and the sorting detail clarifies the return order.

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

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

It explicitly states to use this tool to get an overview of what a file contains, providing clear use context. It does not mention alternatives or when not to use it, so it misses an explicit exclusion or comparison.

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 behavioral disclosure burden. It does this well by revealing that unindexed codebases trigger background indexing, require a retry, and are non-blocking. This is a meaningful side effect beyond a simple 'search' statement. It does not cover edge cases like invalid inputs or error responses, but the core behavior is transparent.

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

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

Three sentences, each earning its place: what the tool does and returns, when to use it instead of grep, and what happens if the index is missing. The most decision-relevant information is front-loaded, with no filler or redundant restatement 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 six-parameter tool with no output schema and no annotations, the description covers the essential context: result content, usage guidance, and the indexing/retry behavior. The schema handles the remaining parameter details. It is slightly incomplete in that it doesn't describe the response envelope, pagination, or limit behavior, but an agent has enough to invoke it correctly.

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

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

Schema description coverage is high at 83%, so the structured schema already documents query, kind, path, team_id, and language. The description reinforces that query is a symbol name or pattern but adds little parameter-level meaning beyond the schema. This matches the baseline for high schema coverage.

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

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

The description opens with a specific verb and resource: 'Search for code symbols by name.' It also states the result shape: matching functions, classes, methods, etc. with file paths and line numbers. This clearly differentiates it from sibling tools like codegraph_callers or codegraph_callees, which explore relationships rather than symbol names.

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 an explicit routing rule: 'Use this INSTEAD of grep when looking for function/class/method definitions.' This is strong concrete guidance for when to invoke it. However, it does not explicitly contrast with related codegraph sibling tools such as codegraph_index, codegraph_list, or codegraph_impact.

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 provided, the description carries the behavioral disclosure burden. It clearly communicates a read-only aggregate-returning operation, but it does not mention potential side effects, required authorization, or any edge cases about missing indexes or empty repos.

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 concise sentences, front-loaded with what the tool returns and followed by its primary use case. Every word contributes to understanding the 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 low-complexity stats tool with two optional parameters and no output schema, the description names the complete set of returned metrics and the intended usage. It lacks only minor behavioral details that would benefit from annotations.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description adds value by clarifying that repo_path scopes the stats, but it does not significantly extend parameter meaning.

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

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

The description uses a specific verb ('Return') with a clear resource ('indexed CodeGraph statistics') and enumerates the exact metrics returned. It also distinguishes itself from sibling search/indexing tools by framing it as a coverage check.

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

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

It explicitly states when to use the tool: 'Use this to check indexing coverage before searching.' This gives clear context for invocation, though it does not name specific alternative tools or explicit when-not conditions.

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

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

The description discloses the side effect of incrementing a Bayesian confirmation count and explains the impact on future searches. It also clarifies the memory state this implies ('accurate'). However, it doesn't specify whether updating or correcting an inaccurate memory would be done via a different tool, which could be relevant context for the agent.

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

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

Three sentences, zero wasted words. Each sentence earns its place: what it does, what happens as a result, and when to use it. The description is immediately understandable and front-loaded with the primary action.

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 simulator with a single parameter and no output schema, the description is concise and effectively conveys the tool's purpose, behavior, and usage, saving the agent from needing to inspect the schema. It could be slightly improved by mentioning the limitations (e.g., no auth or rate limits) but these seem unnecessary for the tool's simple function.

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

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

Schema coverage is 100% for the single parameter 'capture_id', and the description adds the concept that confirming is for 'memories'. However, the description does not clarify what qualifies as a memory or how to reference it, relying on the schema's 'ID of the capture'. It adds a bit of context by linking the 'capture' concept but the link is 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?

The description clearly states the tool's purpose with a specific verb ('Confirm'), resource ('memory'), and mechanism ('Increments the Bayesian confirmation count'). It distinguishes itself from sibling tools by focusing on the confirmation action, which is distinct from tools like 'recall', 'forget', or 'resolve'. The phrase 'raising its confidence score in future searches' adds functional clarity.

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

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

The description provides clear guidance on when to use the tool ('when a recalled memory proved helpful and correct'), but does not explicitly mention when not to use it or name alternatives. Sibling tools like 'correct', 'supersede', or 'forget' are logical alternatives when the memory is inaccurate, but this distinction is not explicitly stated. The usage context is implied rather than contrasted with alternatives.

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

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

No annotations are provided, so the description must convey behavior. It discloses the key distinction: without confirm, it returns groups of similar captures; with confirm=true, it merges them. It also notes batch_size controls processing volume and cost. This is adequate for a tool with a dry-run/merge pattern, though it doesn't discuss side effects or permissions.

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

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

The description is three concise sentences, front-loaded with purpose and usage. Every sentence contributes: purpose, when to use, and key parameter behavior. No redundancy or fluff.

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

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

With 4 parameters and no output schema or annotations, the description covers the core workflow: find candidates, merge with confirm, and use batch_size for incremental processing. It states the return type ('groups of similar captures') but does not detail return structure or threshold behavior, which are adequately explained in the schema. Overall, complete enough for typical use.

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 covers 100% of parameters with detailed descriptions. The description adds minimal value beyond schema: it reinforces confirm's role ('Set confirm=true to merge them') and provides an extra rationale for batch_size ('cost control'), but offers nothing new for threshold or session_key. The added context is marginal.

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

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

The description clearly states the action: 'Find and merge duplicate or near-duplicate memories', with a specific resource (memories). It also differentiates from siblings by providing usage context ('Use this when you suspect redundant captures e.g. same decision captured twice') and describes the two-phase operation (returns candidates vs. merging).

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 when to use: 'Use this when you suspect redundant captures'. It also provides conditional guidance for confirm (set to merge) and batch_size (limit for cost control), but does not explicitly mention alternatives or when not to use it. Still, the context is clear and actionable.

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 provided, the description carries the full burden of disclosure. It states the side effect: increments correction count and lowers confidence score, which is a key behavioral trait. However, it doesn't mention reversibility, permissions, or any additional consequences beyond the confidence adjustment.

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

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

The description is two sentences, front-loaded with the main purpose, and includes the usage guideline in a compact second sentence. Every word earns its place, with no fluff or redundancy.

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 description adequately explains the tool's function and effect, given the simple schema and no output schema. It covers the 'when-to-use' and the impact on future searches. A minor gap is not differentiating when to use correct vs. forget or supersede, but overall it is sufficiently complete for a basic correction tool.

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

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

Schema description coverage is 100%, so both parameters (reason and capture_id) already have descriptions. The tool description adds minimal new meaning, only clarifying that the reason is an explanation of why the memory is wrong, which is largely redundant with the schema. This aligns with the baseline of 3 for high coverage.

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

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

The description clearly states the tool's purpose: 'Mark a memory as inaccurate or outdated.' It also explains the mechanism (increments Bayesian correction count, lowers confidence) which distinguishes it from siblings like forget or supersede. The verb and resource are specific, and the effect on future searches adds unique value.

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

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

Provides explicit guidance on when to use it: 'Use when a recalled memory was wrong, misleading, or superseded by newer information.' This gives clear context, but it does not mention when NOT to use it or alternatives like forget or supersede, which are present in sibling tools.

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 burden. It implies a read-only operation by using 'Get', but does not explicitly state that it modifies nothing, nor does it mention performance characteristics or permissions. This leaves some behavioral aspects undisclosed.

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

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

The description is a single, concise sentence that effectively lists the metrics and the intended use case. No unnecessary words or repetition, making it highly efficient.

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?

Although there is no output schema, the description lists the specific metrics returned (e.g., total corrections, noise candidates) and provides a clear use case. It does not specify the exact data format, but the essential information is present.

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

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

The tool has zero parameters, so the baseline is 4 as per rubric. The description does not need to explain parameters, and no parameter-related information is missing.

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

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

The description clearly states the tool's purpose: to get correction learning metrics, enumerating specific metrics like total corrections and average precision. It uses a clear verb ('Get') and resource ('correction learning metrics'), distinguishing it from other tools.

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

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

The description provides explicit guidance on when to use the tool: 'Use this to evaluate memory quality and identify unhelpful corrections to prune.' It does not mention alternatives, but the context is clear enough for appropriate usage.

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 provided, the description carries full burden. It discloses the tool's output (scores, rank, keywords) and the special behavior when capture_id is provided. However, it doesn't explicitly state whether the tool is read-only or mention any side effects, though the wording 'Shows' implies a non-mutating operation.

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

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

The description is two sentences, tightly packed with relevant information. It front-loads the purpose and includes only essential details, with no redundancy or fluff.

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

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

The tool has 9 parameters and no output schema, but the description compensates by listing the output components (BM25 score, vector score, RRF fused score, rank, keywords). It also explains the capture_id behavior thoroughly. Minor gaps include no mention of error cases or parameter interactions, but the schema covers parameter basics.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the capture_id behavior ('explains why that specific capture was or was not retrieved'), which is not fully detailed in the schema. This extra context justifies a score above baseline.

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

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

The description uses a specific verb ('Explain') and resource ('memory recall'), making the tool's purpose clear. It also distinguishes itself from sibling tools like recall or search by focusing on the explanation of retrieval results and listing specific outputs such as BM25 score and RRF fused score.

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

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

The description explicitly states when to use the tool: 'to debug unexpected recall results or to understand the retrieval pipeline.' This provides clear guidance on the intended use case and implicitly differentiates it from recall, which performs the retrieval itself.

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 provided, the description carries the behavioral disclosure burden. It explains the feedback flywheel effect: "useful memories rise, unhelpful ones fade." The salience mechanics are already present in the parameter schema, so the description adds useful context without needing to repeat them. It could go further by stating irreversibility or persistence, but the current disclosure is solid.

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

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

The description is three sentences with no waste. It front-loads the core purpose, then gives the signal mapping, then explains the flywheel effect and a critical caution. 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?

Given the 100% schema coverage and the simple parameter set, the description is complete enough for an agent to invoke the tool correctly. It specifies when to call, what signals to use, and an important warning. Return value and error handling are not described, but they are not essential for this feedback action.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description restates some signal meanings but does not add meaning beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting and the description does not conflict with it.

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

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

The description clearly states the verb and object: "Record a quality signal for a recalled memory." It also enumerates the specific signal values, making the tool's purpose unambiguous. It does not explicitly distinguish this from sibling feedback-related tools such as record_outcome or correct, so it misses the top score for 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?

The description gives explicit timing guidance: "Call this AFTER using a recall result" and an explicit exclusion: "Do not call this for memories you have not actually used." It does not mention alternative tools or when another tool would be preferable, which prevents 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?

With no annotations, the description must disclose behavioral traits, but it fails to mention the confirm flag that gates execution or the reject mode that turns deletion into a non-destructive tombstone. The description simply says 'delete' without noting these important safeguards or behavioral nuances, leaving a significant transparency gap for a destructive operation.

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 only two sentences, with the first front-loading the purpose and the second adding a critical usage boundary. There is no redundancy, fluff, or wasted words; 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?

The tool has a complex schema with nested filters, a confirmation flag, and a reject mode, yet the description provides almost no context about these behaviors. It does not explain the confirmation workflow, the difference between reject and delete, or how filtering operates. For a potentially destructive tool with no annotations and no output schema, this is significantly under-specified.

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 83% description coverage, so most parameters are already self-documenting. The description adds little beyond the schema: 'specific' hints at id/filter selection but does not clarify how to choose between id and filter, or how confirm and reject interact. This is a standard baseline score for high schema coverage.

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

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

The description states a specific verb and resource: 'Delete specific memory entries.' It is unambiguous and distinguishes the action from siblings like update or consolidate through the strong verb 'delete' and qualifier 'specific.' However, it does not explicitly mention alternative sibling tools, so it does not fully achieve the top score.

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

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

The description gives explicit when and when-not guidance: 'Use this tool only when the user requests a deletion' and 'Do not auto-forget.' This clearly sets the boundary for appropriate use. It does not name alternatives like update or reject, which the schema supports, so it stops short of full 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. It discloses that the tool writes a packet and that recall loads it, and notes token savings. However, it does not mention whether calling it repeatedly overwrites an existing packet, any persistence details, or prerequisites. This is moderate transparency but leaves some behavioral aspects implicit.

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

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

The description is three sentences, each earning its place: purpose, timing, and consequence. It is short, front-loaded, and contains no wasteful or repetitive language.

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 a rich schema and no output schema or annotations, the description is largely complete: it explains the tool's role and its relationship to recall. It could optionally mention the memory isolation fields or overwrite behavior, but given the high schema coverage, this is a minor 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 description itself contains no parameter information, but the input schema covers all 11 parameters with descriptions and enum definitions. Since schema coverage is 100%, the baseline score of 3 applies; the description adds no extra parameter semantics beyond what the schema already provides.

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

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

The description clearly states 'Write a structured handoff packet for the next agent session' with a specific verb and resource. It distinguishes itself from sibling tools by explicitly connecting to 'recall' as the load counterpart, making its role unique.

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

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

It explicitly says 'Call this tool at the end of a session, or before you switch to a different agent' and explains that the next agent 'calls recall to load this packet', providing a clear usage scenario and naming the alternative tool. This leaves no doubt about when to use it.

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 clearly lists what the health check covers, which exceeds a vague 'Use for health checks.' However, it does not explicitly state that the operation is read-only or describe any side effects, which would be valuable for a diagnostic 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 entire description is a single, information-dense sentence with no wasted words. It front-loads the verb 'Diagnose' and immediately lists the key checks, making it easy to scan and understand.

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 health-check tool with no parameters and no output schema, the description covers the essential aspects: the checks performed. It lacks information about the return format or exit status, but given the tool's simplicity, this is a minor omission. The description is complete enough for most use cases.

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

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

The tool has zero parameters, so the schema is trivially complete. The description does not need to explain parameters. The baseline of 4 is appropriate here, and the description adds no unnecessary information.

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

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

The description uses a specific verb 'Diagnose' with a clear object 'memory server health' and lists concrete aspects (DB integrity, index status, capture count, schema version, embedding model). This leaves no doubt about the tool's function and differentiates it from the sibling tools, which focus on other domains.

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 usage context is implied: the user would call this when they need to check the health of the memory server. However, there is no explicit mention of when to use this vs. alternatives, nor when not to use it. Given the tool's self-explanatory nature, this is adequate but not exemplary.

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 provided, the description carries the full burden of behavioral disclosure. It does reveal a key non-obvious behavior: 'The asset metadata is stored locally. The actual content is processed by an external knowledge service.' However, it does not mention side effects, permissions, idempotency, or error behavior, leaving significant gaps for a create operation.

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

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

The description is two sentences, front-loaded with the core purpose, and every phrase adds value. It avoids redundancy and is appropriately concise for a registration 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?

Given the 7-parameter schema with full documentation and no output schema, the description conveys the essential distinction between local metadata and external content processing. However, it lacks critical context such as success/return behavior, whether the operation is idempotent, and how it relates to sibling tools like update or wiki_ingest, making it only minimally 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 100%, so the baseline is 3. The description adds minimal parameter meaning beyond the schema—it mentions the two asset types (already in the enum) and hints at the external service (relating to service_url), but does not clarify optional parameters like branch or repo_url.

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

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

The description clearly states the tool's function: 'Register a knowledge asset (wiki or code-graph) for the team.' It uses a specific verb ('register') with a defined resource ('knowledge asset') and narrows scope with the two types. This distinguishes it from sibling tools like knowledge_get, knowledge_list, and knowledge_delete.

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 useful context by explaining that metadata is stored locally while actual content is processed externally, implying this tool is for registration, not content ingestion. However, it does not explicitly state when to use this tool over alternatives like wiki_ingest or codegraph_index, nor does it mention exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It only states 'Delete...' without disclosing whether the deletion is permanent, reversible, or has side effects. For a destructive operation, this is a significant lack of transparency.

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, well-structured sentence with no redundant words. It front-loads the verb and resource, making it easy to parse quickly.

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

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

This is a destructive tool with no annotations and no output schema. The description fails to mention success/failure behavior, whether IDs must exist, or what happens on partial failures. An agent would lack critical expectations for invoking this tool.

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 fully documents the only parameter (knowledge_ids) with type and description. The tool description adds no new semantic detail beyond 'by ID', which is already in the parameter name. Baseline 3 for 100% schema coverage.

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

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

The description clearly states the action ('Delete'), target ('knowledge assets'), and scope ('by ID', 'one or more'). It distinguishes this from sibling tools like knowledge_create, knowledge_get, and knowledge_list.

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

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

Usage is implied by the verb 'Delete' and the resource, but there is no explicit guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. No mention of when not to use it.

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?

Without annotations, the description carries full responsibility. It only states the basic get action and does not disclose what happens for missing IDs, authentication requirements, return format, or any side effects. This leaves significant behavioral ambiguity.

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, direct sentence with no filler or redundancy. Every word contributes to conveying the tool's purpose.

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 read operation with one fully documented parameter, the description gives enough to invoke the tool correctly. It could mention return behavior or error cases, but the tool's simplicity lowers the burden.

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

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

The input schema fully documents the sole parameter (knowledge_id), and the description adds nothing beyond repeating 'by ID'. Since schema coverage is 100%, the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Get'), identifies the resource ('knowledge asset'), and specifies the scope ('single... by ID'). This clearly distinguishes it from knowledge_list and other sibling getters.

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

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

The description implies use for retrieving a single asset by ID, but gives no explicit guidance on when to use it versus alternatives like knowledge_list or skill_get. No exclusions or alternative tool mentions are provided.

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 provided, the description carries the full burden of behavioral disclosure, but it only states a generic list operation. It does not disclose return format, pagination, ordering, required permissions, or whether the list is limited to summaries versus full objects.

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

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

The description is two short sentences with no wasted words or repetition. It front-loads the main action and uses the second sentence to clarify the optional filter, making it highly concise and readable.

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 list tool with two parameters, the description is minimally sufficient, but it lacks return value details and sibling differentiation. Without an output schema, it would benefit from noting the shape of the returned list and how this tool relates to codegraph_list or wiki_get.

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

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

The schema has 100% description coverage for both parameters, so the baseline is 3. The description adds only the word 'optionally' for the type filter, which is already implied by the schema's non-required status, and provides no additional semantic detail beyond the schema.

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

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

The description clearly states a specific action—'List knowledge assets for a team'—with an optional filter by type. It is easy to understand, but it does not explicitly differentiate itself from sibling listing tools like codegraph_list or skill_list, so it misses the top score.

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 knowledge_get, skill_list, or codegraph_list. It only states what the tool does without any contextual recommendations, prerequisites, 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?

There are no annotations, so the description carries the transparency burden. It adds valuable non-obvious behavior: the persona is injected at SessionStart, it costs roughly 50 tokens per session, and no LLM call is needed—the agent writes the trait/value directly. It does not mention overwrite semantics, permissions, or confirmation output, but it provides stronger behavioral context than a typical update 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?

Two tight sentences front-load the action and trigger, then add only high-value operational details: automatic SessionStart injection, token impact, and no-LLM requirement. Nothing in the description is filler or redundant.

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

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

For a write-only utility with six schema-covered parameters, the description covers the when, the why, and the important side effect (automatic session injection). A brief note on confirmation or return behavior would make it fully complete, but the core invocation context is well covered.

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

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

The input schema already has 100% coverage with clear parameter descriptions, so the schema is doing the heavy lifting. The description's examples ('Vietnamese', 'concise', 'AZR') reinforce the trait/value semantics but add little new meaning. This is the standard '3' baseline for high schema coverage.

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

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

The description clearly states the action and target: 'Update the L3 persona profile for this user/team.' Concrete examples ('prefers concise output', 'works in Vietnamese', 'uses AZR project') further clarify what the tool is for. It does not explicitly differentiate from sibling memory tools like capture or update, but the L3 persona resource is distinctive enough.

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 an explicit trigger: 'Call this when you notice a user preference or pattern.' The examples make the trigger concrete and actionable. It does not state when NOT to use the tool or name alternatives, 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 full burden. It discloses an important behavior: 'Automatically searches both project memory and global cross-project memory (rules, learnings) when REMEM_GLOBAL_SESSION_KEY is configured.' This goes beyond a simple retrieval statement and informs the agent of multi-source search. It does not detail side effects, but for a read-only retrieval tool, this is adequate.

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

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

The description is exactly three sentences, each providing distinct value: purpose, usage timing, and scope of search. It is front-loaded with the core action and efficiently conveys necessary context without redundancy. No wasted words.

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

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

Given the tool has 12 parameters and no output schema, the description could have provided more about return behavior, but it does clarify the global memory feature and when to invoke it. The schema covers parameter details well, so the description complements rather than duplicates. It is reasonably complete for a retrieval tool, though it could hint at response format or pagination, which are covered by the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter semantics beyond what the schema already provides. It does not mention parameters like query, mode, or type, but the schema fully documents them. No extra value is added.

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

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

The description clearly states the verb and resource: 'Retrieve relevant past memory'. This is specific and distinguishes it from sibling tools like 'search' or 'related' by focusing on past memory retrieval. It also adds usage context ('Call this tool before you answer the user') that further clarifies its purpose.

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

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

The description explicitly states when to use the tool: 'Use it when the user references past work or when the task needs project context.' It also provides context about automatic searching across project and global memory. However, it does not mention when not to use it or suggest alternatives, so it falls 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?

No annotations are provided, so the description must carry the full transparency burden. It explains the semantic meaning of the two outcome values and that it records after a correction, but it does not disclose potential side effects, requirements (e.g., whether the correction capture must already exist), error behavior, or whether this is a persistent write. This is a moderate gap for a mutation tool, but the core behavior is reasonably described.

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

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

The description is three short sentences, each earning its place. The first sentence states the core action, the second explains the broader purpose, and the third gives a clear usage instruction. It is 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 tool with only two parameters and no output schema, the description is quite complete: it explains what the tool does, what the outcomes mean, why to use it, and when to call it. It does not describe return values or error cases, but given the tool's simplicity and the full schema coverage, this is not a significant omission.

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

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

The input schema covers 100% of parameter descriptions, so the baseline is 3. The description adds no additional parameter-specific information beyond what the schema already provides (e.g., 'heeded' and 'recurred' are defined in both the schema and the description). Therefore, no extra value is contributed here.

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

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

The description starts with a specific verb+resource: 'Record whether a correction was heeded or recurred', making the tool's purpose unambiguous. It also explains the two outcomes ('agent followed the advice' vs 'same error happened again') and notes it 'tracks correction effectiveness over time', which clearly distinguishes it from sibling tools that apply corrections (e.g., correct, supersede) rather than record their outcomes.

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

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

The description provides explicit timing guidance: 'Call after applying a correction to a recalled memory.' It also implies the context of correction effectiveness tracking. While it does not name alternative tools or state when not to use it, the when-to-use instruction is clear and sufficient for this simple feedback-recording 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It discloses the critical precondition 'Requires REMEM_OFFLOAD_ENABLED=true and pipeline=mermaid', which goes beyond the schema. It could also mention failure behavior or output format, but the described read-only behavior is reasonably transparent.

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

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

The description is two sentences with no filler. It front-loads the primary action, immediately states the use case, and finishes with the essential precondition. Every sentence contributes distinct value.

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

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

For a single-parameter read tool with no output schema and no annotations, the description covers action, use case, and preconditions. The return value is implied ('raw tool output', 'full output'), which is sufficient for this simplicity level. It could be improved with an explicit statement of what the response contains, but it is not a significant 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?

Schema description coverage is 100%, and the schema already provides a concrete example for node_id. The description reinforces the parameter's role but does not add meaningful detail beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly identifies the verb ('Read'), the resource ('raw tool output for a specific canvas node'), and the identifier ('node_id'). It also explains the relationship to the Mermaid canvas and the specifics of drilling down, distinguishing it from canvas-level 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 explicitly states when to use the tool: 'drill down from the Mermaid canvas to the full output when you need details.' It does not explicitly enumerate alternatives or exclusion cases, but for a tool with this specificity, the usage context is clear and actionable.

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 responsibility. It discloses the matching logic (shared tags, project, co-occurrence) and mentions the 'graph spreading-activation' pattern, which adds useful context. However, it does not explicitly state that the operation is read-only or describe response formatting, leaving some behavioral traits undisclosed.

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

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

The description is concise and front-loaded: two sentences convey the main purpose and usage guidance. The additional mention of 'Mnema pattern' is brief and does not bloat the content.

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 two parameters and no output schema, the description gives essential context: purpose, mechanism, and usage timing. It does not describe return value structure explicitly, but the description implies a list of memories, which is sufficient for a simple retrieval tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add significant meaning beyond what the schema already provides; the 'id' parameter is implied as the 'given memory' but the schema already describes it as the capture ID.

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

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

The description clearly states a specific action and resource: 'Find memories connected to a given memory' with the mechanism (shared tags, project, or co-occurrence). It also distinguishes from sibling tools by positioning it as a follow-up to recall or search, making the tool's unique purpose evident.

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

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

The description explicitly states when to use the tool: 'Use this after recall or search to discover related context you might have missed.' This provides a clear usage context. It does not explicitly mention when not to use it or name alternatives, but the given guidance effectively differentiates it from sibling tools.

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 full burden of behavioral disclosure. It states the core effect (mark one winner, one stale), but does not mention irreversibility, permissions, audit logging, or other side effects. The reason parameter's audit log behavior is only in the schema, not the description. This is a significant gap 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 three sentences, front-loaded with the purpose, and lacks unnecessary filler. The second sentence about marking winner/stale clarifies the mechanism without being verbose. It earns a high score for conciseness and structure.

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

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

For a simple mutation tool with no output schema and 100% param coverage, the description plus schema provide a fairly complete picture: what it does, when to use it, and what happens to winner/loser. The lack of output schema doesn't matter. Minor ambiguity about 'capture reports a conflict' but it's understandable in context.

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

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

Schema description coverage is 100%, so parameters are well-documented. The description does not add any parameter-specific meaning beyond the schema, but it doesn't need to. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Resolve a conflict between two captures.' It identifies the specific action (resolve), the resource (captures), and distinguishes itself from siblings like update or consolidate by focusing on conflict resolution between two captures.

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

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

The description explicitly states when to call the tool: 'Call this tool when capture reports a conflict between two memories.' This provides clear context, but it does not mention alternatives or exclusion cases. Thus it meets the criteria for 'clear context, no 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?

The description mentions that a summary is created and that recall will inject it later, implying a write operation. However, it does not disclose any side effects (e.g., overwriting, storage details) or whether the tool is read-only or mutating beyond 'creates'. Since no annotations are provided, the description carries the burden, but it remains incomplete regarding exact behavioral guarantees.

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

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

The description is two sentences, concise and well-organized. It covers the action, condition, benefit, and a critical behavioral note (user writes summary), with no redundant or ambiguous wording.

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 schema covers all inputs and the description explains when and how to use the tool, the overall context is complete. The lack of an output schema is acceptable as it's a creation tool, and the description does not need to explain return values. The mention of 'recall injects' provides integration context.

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 provides detailed descriptions for all parameters (100% coverage), including the purpose of atom_ids and summary, and the optional persona_tags. The description reinforces the usage context without contradicting the schema, ensuring parameter meanings are clear.

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

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

The description clearly states the action (consolidate), resource (L1 atoms into L2 scenario summary), and the condition (5+ atoms about the same topic). It also distinguishes the tool by mentioning the benefit over individual atoms and the lack of LLM dependency, making the purpose unmistakable.

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

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

Explicitly provides a usage condition ('Call this when you have 5+ atoms') and clarifies that the user writes the summary themselves rather than expecting LLM generation. This directly guides when and how to invoke the 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose an important behavior: automatically searching both project and global cross-project memory when REMEM_GLOBAL_SESSION_KEY is configured. However, it does not mention response format defaults, explain behavior, or any side effects, though these are partly covered by schema descriptions.

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

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

The description is two sentences, front-loaded with the core purpose and then the usage guidance and global-scope behavior. Every sentence adds value and there is no redundant or filler content.

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 that this is a complex search tool with 7 parameters, nested filters, multiple modes, and no output schema, the description could be more complete. It covers purpose, usage context, and global-search behavior, but does not mention filtering capabilities, response formats, or explain functionality. Still, the rich input schema compensates for much of this, so an agent can invoke the tool correctly.

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

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

Schema description coverage is 71%, so the schema carries most of the parameter documentation. The description adds meaning by explaining that 'keyword or semantic similarity' maps to the mode parameter, but it does not elaborate on filters, session_key, limit, or format beyond the schema. This is adequate but not exceptional.

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 ('Search memory') and clarifies the two search modes: keyword and semantic similarity. It also explicitly positions the tool against 'recall', saying search is for when recall is too broad and specific facts are needed, which helps distinguish it from a key sibling.

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 a clear when-to-use directive: 'Use this tool when recall is too broad and you need specific facts.' This names the closest alternative and the condition for choosing this tool. It does not explicitly list other alternatives such as knowledge_search or wiki_search, but it provides enough context to guide an agent.

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

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

With no annotations, the description carries the burden of disclosing behavior. It states the tool creates a checkpoint, returns an ID, and stores recent captures as a snapshot, which is useful. However, it does not mention side effects, overwrite behavior, persistence details, or whether existing checkpoints with the same name are affected.

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

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

The description is two sentences, front-loaded with the primary action, and contains no filler. Every clause adds relevant information about purpose, return value, or storage behavior.

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

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

For a simple two-parameter tool with no output schema, the description covers the core purpose, the return value, and the persistence behavior. It could be more complete by explaining what happens on name collision or how the checkpoint is resumed, but the essential context is present.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal semantic value beyond the schema, only reinforcing that the checkpoint is a named snapshot. It does not elaborate on how the summary parameter is used or how the name relates to the returned ID.

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

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

The description clearly states the tool creates a checkpoint of the current session state, returns a checkpoint ID, and stores recent captures as a named snapshot. This specific verb+resource framing distinguishes it from sibling tools like capture or session_start.

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

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

The description implies usage by mentioning the checkpoint ID can be used to resume later, but it does not explicitly state when to use this tool versus alternatives like capture, consolidate, or session_end. No exclusions or alternative recommendations are provided.

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 burden of explaining behavior. It discloses that the session is closed and that a summary can be captured as a memory, which covers the main side effects. However, it does not clarify whether closing is irreversible, what happens to the session record, or how the summary memory is stored or retrieved.

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-load the primary purpose and usage timing. Every word earns its place; no redundancy or filler exists.

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

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

For a simple tool with zero required parameters, no output schema, and 100% schema parameter coverage, the description adequately explains the core behavior and invocation time. It could mention that the session should not be used afterward, but this is not a significant gap given the sibling context and tool simplicity.

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

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

Schema description coverage is 100%, so the schema already documents 'tags' and 'summary' with meaningful descriptions. The tool description does not add further parameter-level detail, such as expected tag formats or relationships between the two parameters, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Close a session') and identifies the resource and optional action ('capture a summary'). This clearly distinguishes it from siblings like session_start and session_checkpoint.

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

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

The description explicitly states when to call it: 'at the end of a conversation to record what was accomplished.' It does not explicitly discuss alternatives or when not to use it, but the timing guidance is clear and sufficient for a simple closure 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?

No annotations are provided, so the description must disclose behavioral traits. It mentions what it returns (recent context, summary, metrics, memory) and the conditional nature of global memory. However, it does not clarify whether opening a session has side effects (e.g., creating a server-side resource, mutating state) or if it is a read-only operation. This leaves some ambiguity about safety and repeatability, though nothing contradicts known behavior.

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

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

The description is two concise sentences that are front-loaded with the primary purpose and usage context. Every sentence contributes: the first states the action and result, the second provides usage guidance and return specifics. No filler or redundant information, making it highly scannable.

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

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

Given the tool's simplicity (2 optional params, no output schema, no annotations), the description covers the essential aspects: what it does, when to use it, and what it returns. It notes the conditional global memory. It does not detail error scenarios or side effects, but for a session start tool, this level of detail is largely adequate. A more explicit note on whether it is safe to call multiple times would push it to 5.

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

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

Schema coverage is 100%, with both session_key and context_query well-described in the schema. The tool description adds no additional semantic detail about these parameters, but the baseline for high schema coverage is 3. The description's mention of 'recent context' and 'summary' indirectly relates to context_query but does not elaborate on its usage beyond the schema.

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

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

The description clearly states the tool's function: 'Open a session and return recent context.' It specifies the verb 'open' and the resource 'session', and further details the return value ('summary of recent captures and correction alignment metrics'). This distinguishes it from sibling tools like session_checkpoint and session_end, which likely serve different phases of a conversation.

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

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

The description explicitly says 'Call this at the start of a multi-turn conversation', providing clear context for when to use it. It also mentions the return of project-specific and global memory 'when configured', which hints at conditional behavior. However, it does not explicitly contrast with alternatives (e.g., session_checkpoint) or state when not to use it, but the 'start' directive is sufficient for most scenarios.

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 discloses the key behavioral consequence (always injected into recall) and the condition under which this matters (weak query match). However, it does not address reversibility, permissions, or side effects on recall behavior beyond the stated injection.

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

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

The description is two sentences with no filler. The action is front-loaded, the behavioral nuance is explained efficiently, and the intended use case is stated in a single clause.

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

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

For a single-parameter tool with no output schema and no nested objects, the description is largely complete: it explains the action, the effect, and the appropriate usage scenario. A note about reversibility or success/error behavior would improve it, but the current coverage is adequate.

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

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

The schema already provides 100% coverage of the only parameter, 'id', with a clear description. The tool description adds no extra parameter semantics beyond the same concept, so a baseline score of 3 is appropriate.

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

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

States a specific action and resource ('Archive a skill') and immediately clarifies the operational effect: it forces the skill to always be injected into recall even on weak query matches. This distinguishes it conceptually from the sibling skill_* tools, though it does not explicitly name an 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 description gives a clear target use case: 'critical SOPs that must always be available.' This tells the agent when to use the tool, but it does not provide exclusions or explicitly compare against alternatives such as normal recall or search, 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?

No annotations are provided, so the description carries the full burden. It adds one meaningful behavioral trait: 'Skills are injected into recall when matching trigger conditions are met.' However, it does not disclose side effects such as overwriting an existing skill, permissions, or what the create response looks like, leaving some opacity for a persistent write operation.

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 sentences, each earning its place: the first defines the action, the second explains the recall behavior, and the third gives the usage trigger. It is front-loaded with the core purpose and contains 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 11-parameter create tool with no annotations and no output schema, the description provides enough context for an agent to select the tool and understand its role in the skill/recall ecosystem. It does not describe the return value or conflict behavior, but the schema fully documents parameters, so the gap is not critical.

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

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

The input schema covers all 11 parameters with descriptions (100% coverage), so the baseline is 3. The description adds no per-parameter semantics beyond an implicit nod to trigger conditions, but because the schema is thorough, no compensation is needed.

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: 'Create a reusable skill (SOP)' and adds source context 'from a successful task or conversation.' The parenthetical SOP clarifies the object type and distinguishes it from knowledge-related siblings, while the create action clearly separates it from skill_get, skill_list, skill_search, and skill_archive.

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

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

Provides an explicit trigger condition: 'Use this after completing a non-trivial task to capture the workflow for reuse.' This gives the agent a clear when-to-use signal, though it does not name alternatives or explicitly state when not to use it, so it stops short of full exclusion 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 of disclosing behavior. It explicitly states that the response includes full content and version, providing useful behavioral context for a read operation. While it omits error handling and auth details, the 'get' verb inherently signals a read, and the description adds meaningful return behavior.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word earns its place, making it highly concise and well-structured.

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 getter, the description is complete: it names the resource, the parameter is fully defined in the schema, and it explains the return payload (full content and version), which is important since there is no output schema. No critical gaps remain.

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

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

The schema provides 100% coverage for skill_id with a clear description, so the baseline is 3. The description's phrase 'by ID' merely restates the schema and adds no new semantic detail.

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

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

The description uses a specific verb ('get') and resource ('a single skill by ID'), clearly distinguishing it from sibling tools like skill_list and skill_search by emphasizing single-item retrieval by ID. The addition of 'including its full content and version' further clarifies the scope.

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

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

The description implies use when you have a specific skill ID and need full content/version, but it does not explicitly mention when to use alternative tools like skill_search or skill_list, nor does it state exclusions. Guidance is present only by implication.

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 for behavioral disclosure. It implies a read-only list operation, which is inherently safe, but it doesn't disclose additional traits such as pagination, ordering, or permission requirements. The agent_id schema description adds some context (returns agent-specific and team-global skills), but the main description remains sparse.

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

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

The description is a single sentence of ten words, highly concise and front-loaded with the core purpose. Every word earns its place, and there is no excess or redundancy.

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 list tool with two well-documented parameters and no output schema, the description is adequate for selection and invocation. It could mention the return format, but for a list operation the expected output (array of skills) is obvious. Overall, it provides enough context for an agent to use 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?

Schema description coverage is 100%, so both parameters are fully documented in the schema. The description's mention of 'optionally filter by agent' adds no new meaning beyond the schema. Since the schema already explains the parameters, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: listing skills bound to a team. It uses a specific verb ('list') and resource ('skills'), and distinguishes itself from sibling tools like skill_get and skill_search by specifying the team-scoping and optional agent filter.

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

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

The description provides clear context: use this tool to list skills associated with a team, optionally filtered by agent. It doesn't explicitly mention alternatives or exclusions, but the scope is clear enough for an agent to decide when to use it.

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 implicitly indicates a read-only operation through 'search' and discloses the return format, but does not mention specifics about required parameters (team_id, agent_id) serving as scoping context or any potential rate limits/pagination behavior. This adds minimal but non-trivial behavioral info.

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

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

The description is exactly two sentences, front-loaded with the core action and a clear statement of the return value. No redundant or filler content; every word 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?

Given the tool's simplicity, the description plus schema cover the essential aspects: what it does, what it returns, and all parameters. It lacks usage guidance and a bit more scoping context, but for a basic search tool this is adequately complete for an agent to invoke it correctly.

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

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

The schema provides 100% coverage, with descriptions for all four parameters (query, team_id, agent_id, topK). The description does not add any meaning beyond what the schema already states, matching the baseline for high schema coverage.

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

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

The description clearly states the tool's function: 'Search skills by keyword' and specifies the return value ('Returns matching skills with descriptions'). This distinguishes it from sibling tools like skill_get (retrieval by ID) and skill_list (listing all), making the purpose unambiguous.

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 usage is implied by the name and description: search for skills when you need a keyword-based lookup. However, there is no explicit guidance on when to use this tool instead of alternatives like skill_get or search, nor any exclusions or recommendations, so it stays at the implied-usage level.

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 provided, the description carries the behavioral transparency burden. It communicates that this is a read-only summary operation ('Query', 'returns a summary') and lists the information it provides, but it does not explicitly state side-effect-free behavior, output format, or implications of the optional session_key filter beyond the schema.

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

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

The description is two sentences, front-loaded with the core verb and resource, and each sentence adds value: one defines the output contents and the other frames the use case. There is no redundancy or unnecessary detail.

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

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

For a simple tool with one optional parameter, full schema coverage, and no output schema, the description provides enough information to understand purpose, usage, and returned summary contents. It could be more complete by elaborating on the summary format or explicitly noting that an argument can scope the results, but it is not materially 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 description coverage is 100%, so the baseline is 3. The description adds the phrase 'No arguments needed,' which matches the optional parameter design but may slightly understate the session_key filtering capability. It does not meaningfully enrich the schema's own parameter description.

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

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

The description clearly states the tool's purpose: 'Query memory statistics' and enumerates specific outputs including total captures, breakdown by type, top tags, session count, date range, and database size. This is specific enough to distinguish from sibling tools like health or recall, which suggest broader or different functionality.

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

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

The description provides clear context: 'Use this to understand memory health and coverage' and notes that 'No arguments needed — returns a summary.' It does not explicitly name alternatives or exclusion criteria, but the use case is well framed for an optional-parameter statistics 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?

With no annotations provided, the description carries the behavioral burden. It discloses the key side effect: the old memory's superseded_by field is set and it 'will be filtered out of search results (unless explicitly requested).' This tells the agent that the old memory is retained but hidden, which is meaningful behavioral context beyond the schema.

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

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

The description is two sentences, front-loaded with the action, includes a brief parenthetical about search filtering, and ends with a clarifying example. Every sentence contributes useful information with no redundancy or filler.

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

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

For a simple two-parameter tool with no annotations and no output schema, the description covers purpose, side effects, behavior in search results, and when to use it. It could add edge-case details like validation of IDs or reversibility, but these are not essential for the tool's core operation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces which ID is old versus new through its wording and example, but it does not add substantial per-parameter detail beyond what the schema already provides.

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

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

The description clearly states the specific action: 'Mark an old memory as superseded by a newer one,' naming the exact resource (memory) and the mechanism (setting superseded_by). It also provides a concrete example ('database is MySQL' → 'database is PostgreSQL') and distinguishes this from sibling tools like forget or update by emphasizing the old/new relationship.

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 an explicit usage trigger: 'Use when a fact has changed,' with an illustrative example. It does not explicitly name alternatives or state when not to use this tool, so it stops short of a full 5, but the context is clear and actionable.

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. It discloses a key behavioral trait: 'Preserves the original ID and created_at,' which is valuable information beyond the schema. However, it does not mention other behavioral aspects like irreversibility, permissions, or side effects on related data, which would be helpful 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 concise and well-structured: two sentences that immediately state the action, provide usage guidance, and add a clarifying behavioral note. Every word earns its place, and the front-loaded structure makes the primary purpose clear at a glance.

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

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

Given the tool's moderate complexity (5 parameters, no output schema, no annotations), the description covers the essential context: what it does, when to use it, and a key preservation behavior. It could mention return values or error cases, but for a simple update operation on a memory entry, the description is sufficiently 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?

The input schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds little beyond the schema: it mentions 'missing tags' and 'rewording,' which loosely map to the tags and content parameters, but the schema already explains them. No additional parameter-level nuance is provided.

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

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

The description clearly states the verb and resource: 'Update an existing memory entry.' It also specifies the purpose with concrete examples ('wrong info, missing tags, needs rewording'), distinguishing it from creation tools like capture. The added note about preserving ID and created_at reinforces its scope.

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

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

The description explicitly tells when to use the tool: 'Use this when a capture needs corrections.' This provides clear context, though it does not explicitly name alternative tools or state when not to use it. It implies that for new captures, you would use capture rather than update.

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 provided, the description carries the full burden. It discloses that this is a read operation ('read a specific page') and what is returned ('links and backlinks'), but doesn't address error cases, authentication, or response structure. This is adequate for a simple getter but lacks depth.

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 concise sentences that front-load the core purpose and add a usage note. Every word 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 single-parameter, no-output-schema read tool, the description covers purpose, usage, and key return aspects. It could be more detailed about failure behavior, but overall it's sufficiently complete for straightforward 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 coverage is 100% and the page_id description already explains its provenance ('from wiki_search'). The description's 'by ID' reinforces but doesn't add much beyond the schema, so baseline 3 applies.

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

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

The description clearly states a specific action ('Get a wiki page by ID') and adds scope ('including its links and backlinks'), distinguishing it from sibling tools like wiki_search and wiki_outdated.

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 second sentence provides explicit usage context ('Use this to read a specific page and see what it links to and what links to it'), but it doesn't mention when to avoid this tool or explicitly name alternatives, though the schema's reference to wiki_search implies a prerequisite.

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 provided, the description carries the full burden. It discloses the parsing behavior and supported file types, but lacks critical side-effect information such as whether ingestion overwrites/merges existing pages, requires specific permissions, or is destructive. This is a significant gap for a write operation.

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

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

The description is two concise, front-loaded sentences. It immediately states the primary action and then adds valuable detail about parsing and supported file types, with no unnecessary 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?

The description covers the core functionality and parsing details but omits what the tool returns or how it affects existing data. With no output schema and no annotations, the description should explain the outcome and potential side effects for an ingest tool, which it does not.

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

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

The schema already covers all parameters with 100% description coverage, so the description's additions are modest. However, it explicitly states that only .md and .markdown files are supported, which is not present in the schema and clarifies a constraint on the path 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?

The description clearly states the tool ingests markdown files into the wiki and details the parsing process (frontmatter, headings, wikilinks, links). This specific verb+resource combination effectively distinguishes it from sibling read tools like wiki_search and wiki_get.

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

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

The description implies the tool is for adding markdown documentation but does not explicitly specify when to use it over alternatives like update or capture. There is no explicit when-not-to-use guidance or mention of 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 the transparency burden. It discloses that the tool returns pages needing re-ingestion and that it reacts to source file modification/deletion, implying a read-only operation. However, it does not describe the return format, team_id isolation behavior, or any side effects.

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

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

The description is a single sentence that is front-loaded with the action and scope. Every word earns its place, with no redundancy.

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

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

The tool is simple with only two parameters and no output schema. The description explains the purpose and trigger but leaves the return structure vague ('pages' could mean paths, IDs, etc.). It does not mention prerequisites like having run wiki_ingest, but this is likely 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?

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-specific details beyond the schema's own descriptions of repo_path and team_id, which are already clear.

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

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

The description uses a specific verb ('find'), resource ('wiki pages'), and scope ('whose source file has changed since the last ingest'). It clearly distinguishes from sibling tools like wiki_ingest (which performs the ingest) and wiki_search (which searches content).

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 clearly implies the use case: identifying wiki pages that need re-ingesting after source changes. It provides clear context but does not explicitly mention alternatives or when not to use the 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?

With no annotations, the description carries full burden for behavioral disclosure. It does state the return format (title, file path, snippet), which is useful. However, it omits the team_id scoping behavior and limit enforcement, and does not explicitly confirm read-only nature or any prerequisites. Minimal but not misleading.

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

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

The description is three short, front-loaded sentences: 'Search wiki pages by content. Returns matching pages with title, file path, and a snippet. Use this to find documentation relevant to a topic.' Every sentence contributes meaning with no fluff or redundancy.

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?

No output schema exists, so the description must explain return values, which it does. However, it omits important operational context such as team_id isolation and limit behavior, which are needed for correct invocation. The description is adequate for simple use but incomplete for full self-sufficiency.

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 67% (query and team_id have descriptions, limit does not). The tool description adds no parameter-specific guidance beyond implying query is content search. The limit parameter is left undocumented in both schema and description, and there is no explanation of FTS5 syntax or team isolation semantics in the description.

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

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

The description clearly states 'Search wiki pages by content,' specifying both the verb and the resource. It also distinguishes itself from sibling tools like wiki_get or wiki_ingest by focusing on content-based search and return of title, file path, and snippet. The phrase 'Use this to find documentation relevant to a topic' reinforces the specific purpose.

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

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

The description provides explicit context: 'Use this to find documentation relevant to a topic.' However, it does not mention when not to use this tool or name alternative tools for different scenarios, such as retrieving a specific page with wiki_get or general search with search. Lacks exclusions but gives clear usage.

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