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

Annotations already encode destructiveHint=true, and the description appropriately supports this by stating the tool can 'run' named tools with arguments. It also discloses important behavior: query returns full ready-to-call schemas)Skip; these are exactly WHAT the schema already says, but the description adds the meta-context that this tool can have destructive effects because it can run arbitrary hidden tools. A 4 seems high but justified; only minor lack is explicit caution/warning or side-effect caveats, which annotations already flag.

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, front-loaded with the most important directive (search before concluding absence), then mode details. No filler or redundant restatement of schema fields.

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 bridge/dispatcher tool, the description covers the full calling pattern: when to use it, how to search, what search returns, and how to execute. No output schema exists, but the description states the key return behavior (full schemas). Coupled with 100% schema coverage and strong annotations, nothing essential is missing.

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

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

Schema description coverage is 100%, so the schema already explains all three parameters. The description adds semantic clarity beyond raw parameter names by explaining how query, name, and args interrelate (e.g., name must come from a previous query result and defines the execution mode). It correctly avoids re-listing parameter mechanics.

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 tool as a discovery-and-execution gateway for 59 ContextForge capabilities absent from the visible tool list. Its phrase 'not in your tool list' and enumeration of capability areas (git sync, spaces, projects, etc.) distinguish it from sibling memory/task 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 to search here before concluding a ContextForge capability doesn't exist, and precisely differentiates the two modes: query for searching (returns schemas) versus name plus args for execution. No ambiguity about when or how to invoke.

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

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

Annotations already indicate readOnly and idempotent behavior. The description adds specific behavioral details: it uses a local git diff, no data leaves the machine, and returns up to 3 stale memories. This context enhances understanding beyond annotations.

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

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

Three concise sentences: first states purpose, second explains mechanism and privacy, third gives usage advice. 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?

Given no output schema, the description covers purpose, mechanism, privacy, return value (up to 3 items), and usage frequency. The single optional parameter is well-documented in the schema. No gaps identified.

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

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

With only one optional parameter (space_id) and 100% schema coverage, the description does not add meaning beyond the schema's description. 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 states the tool checks if memories linked to git-tracked code are stale by comparing commit SHAs, using a specific verb ('check') and resource ('freshness of memories'). It distinguishes from siblings like memory_ingest and memory_query by its unique caching context.

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 advises calling 'periodically or when you suspect saved context might be out of date,' providing clear usage context. It does not explicitly list when not to use or alternatives, but the guidance is sufficient for general 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?

The description adds meaningful behavioral context beyond annotations: it updates the confirmed timestamp and suppresses re-flagging until the code changes further. This explains the effect and side-effect, while idempotentHint already indicated safe repetition. No contradiction.

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

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

Two sentences with no wordiness. The first sentence states the core action and condition; the second explains the effect. Every sentence serves a 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 one-parameter tool with no output schema, the description adequately explains purpose, effect, and relation to memory_check_freshness. It could mention error handling (e.g., if the id is not flagged) for completeness, but overall it is sufficient.

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

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

The single parameter 'id' is fully described in the schema (UUID of the memory item). The tool description does not add further meaning about the parameter, but the baseline is 3 due to high schema coverage. The description references the context of flagging, which indirectly clarifies what kind of id is accepted.

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 tool's purpose: confirming a memory flagged by memory_check_freshness as still accurate. It specifies the resource ('memory flagged by memory_check_freshness') and the verb ('confirm'), and distinguishes from related tools like memory_correct and memory_forget by referencing the flagging mechanism.

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 when memory_check_freshness has flagged a memory and the agent believes it is still accurate. It does not explicitly state when not to use it or alternatives, but the context is sufficient for an AI agent familiar with the memory ecosystem to make appropriate decisions.

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?

All annotations are false-valued (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), so the description carries the full behavioral burden. It discloses that the tool 'Replaces the stored content' and — crucially — that it 'refreshes the git context (current commit SHA) so future freshness checks compare against the new baseline', a side effect not visible in the schema. It stops just short of explaining failure modes or preconditions like git connectivity.

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 with zero waste: sentence one states trigger and action, sentence two discloses side effects, sentence three routes to the sibling alternative. The scoping condition is front-loaded ahead of the side-effect detail. 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?

For a simple write tool with 2 required params and no output schema, the description covers the trigger context, the mutation, the git-baseline side effect, and the sibling distinction. Minor gaps exist — failure behavior, return value, and preconditions (e.g., whether the git repo must be connected) are unstated — but nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so id, content, and related_paths are already fully documented structurally. The description adds workflow context (what 'corrected content' means in this freshness-check flow, why related_paths matters for the git baseline) but no new formats, constraints, or syntax. Baseline 3 is appropriate since the schema does the heavy lifting.

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 ('Update'), resource ('a memory'), and precise scope ('flagged by memory_check_freshness'), which immediately distinguishes it from the broader memory_update sibling named in the last sentence. The annotation title 'Correct Memory' reinforces the same purpose. An agent can tell exactly what this tool is for without opening any other definition.

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

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

Gives an explicit when-to-use trigger ('after its related code changed', 'flagged by memory_check_freshness') and an explicit when-not-to-use rule with the named alternative: 'For a general edit to any memory that is NOT part of a freshness check, use memory_update instead.' This is ideal routing guidance — nothing left to inference.

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

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

Annotations already indicate destructive and idempotent behavior. Description adds context that the tool targets 'no longer relevant or accurate' memories sourced from freshness checks, which is helpful beyond annotations.

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

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

Two concise sentences with no wasted words. Front-loaded with the core action and resource, then immediately follows with usage guidance.

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 destructive tool with good annotations, the description fully covers purpose, usage context, and relationship to alternatives. No gaps in what an agent needs to know.

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

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

Only one parameter 'id' with full schema description. Description does not add extra meaning beyond the schema, meeting the baseline 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?

Description clearly specifies the action ('Delete') and the specific resource ('memory flagged by memory_check_freshness'). Explicitly distinguishes from sibling tool memory_delete, which is a nearby 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?

Description explicitly states when to use this tool ('when acting directly on a freshness check result') and directs to use memory_delete otherwise, providing clear 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds no extra behavioral context. It does not contradict annotations. With annotations covering safety, a score of 3 is appropriate.

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?

Single sentence, zero waste. Front-loaded with key action and scope. Perfectly concise.

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

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

For a zero-parameter help tool, the description is sufficient. It could optionally mention output format, but not necessary. Annotations cover safety. Minor gap: no mention of interactivity.

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?

No parameters exist (0 params), so schema coverage is 100%. According to guidelines, baseline is 4. Description adds no parameter info but none 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?

Description clearly states it shows help and usage instructions for memory commands. Verb 'show' and resource 'help' are specific. Given sibling tools are all memory commands, this distinguishes itself as the help command.

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 purpose is clear: use when you need help with memory commands. No explicit when-not-to-use or alternatives, but the context is obvious from the name and sibling list. Adequate for a zero-parameter help tool.

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

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

Annotations already signal read/write behavior (readOnlyHint=false, destructiveHint=false), and the description adds meaningful behavioral context: deduplication semantics (default true, with guidance to set false), and the consequence of omitting space (piles into default space). It also implies long-term persistence and retrieval via semantic search. No contradiction detected; only minor missing detail like side effects on existing entries, but not required given annotations.

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

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

The description is long but tightly structured with bold headings, front-loading the core purpose and examples, then routing guidance. Every sentence earns its place; no fluff or repetition. The length is justified by the tool's complexity and the need to convey proactivity and space routing.

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 complexity (9 params, multiple behaviors) and absence of an output schema, the description covers when to use, what to save, parameter priorities, space routing, deduplication, and how to discover spaces. No critical missing information. The only minor gap is return behavior, but without an output schema that's not required. Complete for effective 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, so baseline is 3. The description adds value by emphasizing meaningful title and tags for discoverability, explaining space_id's role via 'pass space:'<name>'' and default fallback, and clarifying deduplicate behavior. Not all parameters are elaborated (source_uri, related_paths), but those are self-explanatory and don't require extra context. This exceeds the 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 states a specific verb ('save'), a resource ('persistent memory'), and a clear scope: information valuable for future conversations, with concrete examples like project decisions and user preferences. It also conveys proactivity and distinguishes itself from memory_query by noting that query will later surface what was saved. This fully differentiates the tool's 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?

Provides explicit when-to-use guidance ('Call this WHENEVER...'), a decision heuristic ('if you would be sad to lose this fact'), and preference for over-saving. It also gives routing instructions with spaces, including how to discover spaces via cf_tools, and warns against default-space usage in multi-space projects. This is exceptionally 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?

Annotations already indicate readOnlyHint=true and idempotentHint=true. Description adds that it returns semantically relevant content and must be called even if the AI thinks it remembers, which goes beyond the annotations.

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

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

The description is verbose with imperative instructions and repeated emphasis on the consequences of skipping. While informative, it could be more concise and front-loaded.

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 thoroughly covers the tool's role and usage context despite the lack of an output schema. It compensates for the missing return value documentation by stressing the importance of the 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 extra meaning beyond the schema's parameter descriptions, focusing instead on usage context.

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 explicitly states 'Search persistent memory' and instructs when to use it before answering project-specific questions, clearly distinguishing it from siblings like memory_get_item or memory_list_items.

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 conditions: at conversation start, when prior context is referenced, before architectural decisions. Includes warnings about consequences of skipping, fulfilling the 'when-not' and 'alternatives' implicitly by omission.

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

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

With no annotations, the description carries full burden and discloses key behaviors: sessions expire ~10 min after last heartbeat, default scoping to the current project, fallback to organization if no project linked, and parameter interactions. No contradictions.

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 moderate-length paragraph with key information front-loaded. Each sentence adds value, and there is no redundant or repetitive content. Could be slightly more concise, but overall 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?

Given no output schema, the description provides sufficient context about behavior and parameter effects. It mentions that the tool shows 'what each is focused on,' hinting at output structure. For a listing tool, it covers the major aspects needed for correct invocation.

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

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

Schema coverage is 100% with individual parameter descriptions. The description adds extra semantics, such as explaining that `all_projects` is ignored when `project` is provided, which goes beyond the schema. It also clarifies default behavior for scoping.

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

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

The description starts with a specific verb and resource: "List OTHER live Claude Code sessions working on the same project right now, and what each is focused on." It clearly distinguishes from sibling tools like session_end and session_update, and no other tool lists live sessions.

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 at conversation start and before big changes to avoid stepping on parallel sessions." It also explains default scoping and fallback behavior. However, it does not explicitly mention when not to use it or contrast 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral details such as default sorting, surfacing overdue tasks, and the requirement to include clickable dashboard URLs, which go beyond annotations.

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

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

The description is informative but slightly lengthy. However, critical usage instructions are front-loaded in bold, and the rest is structured logically. A minor improvement would be to trim redundant phrasing, but it remains clear and effective.

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

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

Given no output schema, the description covers key behaviors: default view, sorting, status filtering, and the critical requirement to include dashboard links and surface overdue tasks. It provides sufficient context for an agent to use 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 coverage is 100%, so baseline is 3. The description adds extra meaning by explaining default for status (pending) and that overdue tasks should be surfaced. It also highlights the dashboard URL, though not a parameter, it informs output handling.

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 lists tasks, with specific verb 'call' and resource 'tasks'. It distinguishes from sibling task tools (like tasks_create) by focusing on listing. It also specifies default behavior (pending, sorted by due date, urgent first) and optional filters.

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 instructs when to call: 'at start of any conversation about work, planning, or status — and any time the user asks about pending/open/in-progress tasks.' It also explains how to use status parameter and emphasizes including dashboard links.

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

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

Annotations already declare readOnlyHint and idempotentHint. Description adds that it returns highest-priority unresolved task with due date and priority, and instructs to include dashboard URL. No additional behavioral details beyond annotations, but enough for safe use.

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?

Concise, front-loads purpose and trigger phrases. Could be slightly tighter, but each sentence adds value. 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?

For a tool with no parameters and no output schema, the description covers purpose, trigger phrases, output content, and best practices. Missing explicit mention of error cases or edge conditions, but 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?

No parameters, so baseline 4. Description doesn't need to add parameter info. Mentions output format briefly, which is helpful.

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?

Description clearly states the tool returns the highest-priority unresolved task for the user, with explicit trigger phrases and usage context. Distinguishes from sibling tools like tasks_list or tasks_create by focusing on 'what's next' rather than general task 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?

Provides explicit trigger phrases and advises preferring this over generic answers when user seems unsure. Lacks explicit 'do not use for' conditions, but context from sibling tools implies boundaries. Slight gap in completeness.

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