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

No annotations are provided, so the description carries full burden. It lacks disclosure of important behavioral traits such as idempotency, error handling for invalid keys, network requirements, or side effects of activation.

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 extremely concise with two sentences: first stating purpose and listing unlocked tools, second providing a URL. No unnecessary words, 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?

Given the tool's simplicity (2 params, no output schema), the description covers the basic activation purpose but lacks behavioral details and does not reference related tools like activation_status for 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 coverage is 100% with both parameters described. The tool description does not add further meaning beyond the schema, so 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 clearly states the action ('Activate a ContextEngine Pro license') and the result ('unlock premium tools'). It lists specific tools unlocked, distinguishing it from siblings like activation_status.

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

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

The description provides clear context for when to use the tool (to activate a license) and includes a link to obtain one. However, it does not explicitly mention when not to use it or alternatives like activation_status.

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

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

With no annotations, the description carries full burden. It clearly indicates a read-only operation via 'Check'. While it could mention authentication or side effects, for a simple status check with no parameters, it is sufficiently 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 a single sentence of eight words, directly front-loading the key information with no unnecessary text.

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 and no annotations, the description adequately specifies what the tool checks (license status, plan, premium tools). It provides enough context for an agent to understand the tool's purpose and expected return.

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

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

There are zero parameters, so baseline 4 applies. The description does not need to add parameter details since none exist.

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

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

The description clearly states the verb 'Check' and the specific resource 'ContextEngine license status, plan, and available premium tools'. It directly distinguishes from the sibling tool 'activate' which implies a mutation.

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 license information is needed but does not explicitly state when not to use it or provide alternatives. Given the sibling tools, the context is clear, but no direct guidance is given.

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 of behavioral disclosure. It details the data source (local transcripts), cost basis (API list prices), special markers (NOTIONAL/UNPRICED), capacity metrics, and threshold fallback from policy.json. It implies a read-only report but never explicitly states side effects or access requirements, so it's not a 5.

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

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

Three dense sentences front-load the report's contents, then give usage timing and threshold sources. The metric enumeration makes it longer than minimal, but every sentence contributes information the agent needs.

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

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

The description covers what the report contains, where the data comes from, pricing caveats, threshold sources, and when to call it. Given no output schema and no annotations, this is fairly complete, though it lacks an explicit example and an unambiguous side-effect statement.

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 general context about thresholds and report contents but does not add per-parameter meaning beyond what each schema property already states.

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 it produces a 'Multi-agent cost report' from Claude Code's own transcripts on this machine, listing specific metrics (tokens, cost, capacity intensity, top runs, signals). The resource and scope are precise and clearly differentiate it from sibling tools like run_audit or score_project.

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 explicit timing guidance: 'Call it after a fan-out to read what it consumed, or before one to compare with the last.' This is clear context, but the description does not name alternative tools or when-not-to-use conditions, 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?

Without annotations, the description must disclose behavioral traits. It explains the return values (OK+count or BROKEN+index), the existence and location of the audit log file, and the compliance evidence context. It does not contradict any annotations (none present).

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 well-structured: first sentence states purpose, second details return values, third adds compliance context. It is front-loaded and informative, though the compliance evidence sentence is relatively long and might be streamlined.

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 adequately explains return values (OK+count, BROKEN+index) and the nature of the audit log. It does not cover error cases (e.g., log file missing), but the overall context is sufficiently complete for a verification 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 input schema covers both parameters (since, until) with 100% coverage. The description adds context by explaining that these parameters restrict counters while the chain is still verified end-to-end. This goes beyond the schema's descriptions.

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 that the tool verifies the integrity of the local audit log chain and returns OK or BROKEN results. It specifies the resource (audit log) and the action (verify). However, it does not explicitly distinguish this tool from its sibling 'run_audit', which may also perform audit-related functions.

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 lacks guidance on when to use this tool versus alternatives. It does not mention prerequisites, conditions, or scenarios where this tool is preferred over sibling tools like 'run_audit' or others.

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

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

Since no annotations are provided, the description carries full burden. It describes scanning and returning a conflict map, implying read-only behavior. However, it does not explicitly state non-destructive nature, but the 'scan' and 'returns' language is sufficient.

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?

Extremely concise: two sentences. First covers purpose and files, second covers output and license. 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 no output schema, the description mentions output type (port allocation map with warnings), which is helpful. It could add more detail on map format or error handling, but for a simple tool with no params, it's quite 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?

No parameters exist, so schema coverage is 100%. The description adds no param info (unnecessary), but mentions file types which provides context. Baseline for zero params is 4.

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 it scans all projects for port declarations and detects conflicts, specifying file types. The verb 'scan' and resource 'projects' are specific, and it distinguishes from siblings which focus on other areas like activation, sessions, audits.

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 mentions a prerequisite (Pro license) and implies usage for port conflict detection. It lacks explicit when/not-to-use or alternatives, but given no sibling tool does port checking, it's clear enough.

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 bears full responsibility. It states the destructive action ('delete') but lacks disclosure of side effects, permissions, reversibility, or error behavior. The minimal information is insufficient 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?

Two sentences, no redundancy, front-loaded with action. Every word serves a purpose. 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?

Given the simple single-parameter nature, the description covers the essential action and provides a useful prerequisite. However, it omits details about return values, error handling, and behavioral nuances that would aid an agent in robust usage.

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 'id' parameter is fully described in the schema (100% coverage). The description repeats the ID usage but adds no additional semantic meaning beyond the schema. The prerequisite hint (list_learnings) is useful but not directly parameter-related.

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 a learning by its ID') and distinguishes it from siblings like list_learnings and import_learnings. The verb 'delete' and resource 'learning' are specific and 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?

Explicitly advises using list_learnings first to obtain the ID, providing a clear prerequisite and workflow direction. Does not mention when not to use or name specific alternatives, but the guidance is helpful.

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 provided, so description carries the burden. Mentions 'Returns success/not-found,' which indicates outcomes. However, lacks details on irreversibility, permissions needed, or 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?

Two sentences: first states action and return, second provides usage context. Every 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 simple delete tool with one parameter, the description covers the action, return, and usage. Could mention irreversibility, but the 'not-found' return implies the session may not exist. Adequate given 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% with the 'name' parameter already described. The description adds 'by name' which matches the schema, but no additional semantic value beyond what's in 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?

Clearly states 'Delete a saved session by name' with specific verb and resource. Distinguishes from sibling tools like save_session and load_session by focusing on deletion. Also mentions return behavior.

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 says 'Use for cleanup of stale or obsolete session context,' which provides clear context for when to use. Does not explicitly mention when not to use, but the intent is clear enough.

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 fully discloses the tool's behavior: it returns specific signal types and includes a recommended action for critical cases. It does not mention side effects but implies a read-only 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 purpose, and contains no wasted words. Every sentence adds 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?

The description covers the output (signal types) and a usage recommendation, making it sufficiently complete for a simple read tool without output schema. It lacks details on parameter effects 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 coverage is 100%, so the description doesn't need to explain parameters. It does not add any extra meaning beyond the schema, which is adequate.

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 it returns active drift/loop/fabrication signals, using specific verbs and resource types. It distinguishes itself from sibling tools like run_audit by focusing on a specific self-check function.

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 advises when to use ('before starting a major task phase') and what to do if critical signals are found ('pause and surface to human'). While it doesn't discuss when not to use, the guidance is actionable and clear.

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?

Although the description details what the tool checks and returns, it does not explicitly state that it is read-only or non-destructive, nor does it discuss potential side effects or permissions. With no annotations provided, the description falls short of fully disclosing behavioral traits.

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 with three short sentences. It front-loads the critical usage instruction ('MUST be called before ending any coding session') and provides all necessary details without extraneous information.

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

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

Given the tool's simplicity (no parameters, no output schema), the description covers the essential aspects: what it checks, what it returns (PASS/FAIL checklist), and the required follow-up action. It could mention idempotency or the absence of side effects, but it is generally complete for its purpose.

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 has no parameters, so schema coverage is 100%. The description does not need to add parameter information. Baseline score for zero parameters is 4, and the description meets this standard.

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 be called before ending a coding session, checking for uncommitted changes and documentation freshness. It uses a specific verb (end/check) and resource (session), and distinguishes its role from sibling tools like save_session or delete_session by focusing on pre-termination verification.

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 (before ending any coding session) and what to do after (resolve all FAIL items). It lacks explicit exclusion or mention of alternatives, but the context is clear enough for an AI agent to decide when to invoke 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?

With no annotations provided, the description carries the full burden, and it delivers: it details exactly what counts as marked, what permissive=true adds, and states deduplication. It does not mention side effects, errors, or write confirmation, but the import behavior is well specified.

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 dense but every sentence adds relevant information: file types, default marked behavior, permissive mode, and deduplication. It is front-loaded with the core purpose and avoids 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?

Given the tool's moderate complexity, the description covers the core import rules, deduplication, and parameter behavior. It does not describe the return value or error handling, but no output schema exists and the provided detail is sufficient for correct invocation.

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

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

Schema description coverage is 100%, so all parameters are already documented in the schema. The description reinforces the permissive parameter's meaning and adds detail about rule extraction, but it does not materially extend the meaning of project or default_category beyond their schema descriptions.

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 bulk-imports learnings from Markdown or JSON files, with specific verb and resource. It is easily distinguished from the sibling save_learning, which implies single-item saving.

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 explains the default marked-only behavior and when to set permissive=true, giving clear context for typical use. It does not explicitly mention alternatives like save_learning, but 'bulk-import' communicates the batch use case well enough.

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 behavioral disclosure burden. It adds meaningful context: learnings are 'permanent', contain 'operational rules that have been discovered across sessions', and are automatically indexed in search results. It does not explicitly state read-only safety or return behavior, but 'List' combined with the permanence and search-integration notes is sufficient context for a simple read 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 efficient sentences with no filler. It front-loads the main action, clarifies the resource nature, and then provides the sibling-tool routing, all in minimal space.

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, optional-parameter list tool, the description covers the core semantics, the alternative keyword-search path, and the distinctive permanence/indexing behavior. The `since` parameter is left entirely to the schema, but the schema covers it thoroughly, and there is no output schema to explain. Minor gaps such as ordering or pagination are not critical for 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?

Schema description coverage is 100%, so the schema already documents both optional parameters in detail, including the 'since' boundary semantics and category examples. The description adds only the category-filter concept, which is already present in the schema, so the baseline of 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 opens with a specific verb and resource: 'List all permanent learnings, optionally filtered by category.' It clearly distinguishes this tool from sibling search_context, which is routed to for keyword-based lookup.

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 search_context instead ('Use search_context to find learnings by keyword'), and explains that learnings are automatically included in search results. This gives a clear decision rule between two overlapping 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 Pro license requirement and details the output content (tech stack, infrastructure, git status). This is sufficient for a read-only listing 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, front-loaded with the primary purpose, and every sentence adds value. No extraneous text.

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 zero parameters, no output schema, and no annotations, the description provides enough context: what the tool does, what it returns (specific fields), and a prerequisite. The tool is simple and fully 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?

There are zero parameters, so baseline score is 4. The description does not need to add parameter information beyond the empty 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 discovers and analyzes all projects in the workspace, specifying what information is shown (tech stack, infrastructure, git remote status). It distinguishes from sibling tools that list other entities like sessions or sources.

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 project discovery and analysis but lacks explicit when-to-use or when-not-to-use guidance. It mentions a Pro license requirement but does not reference 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 provided, so description carries full burden. It clearly states it lists all sessions with specific fields, implying a read-only operation. Could add more on scope (e.g., current user) or confirm no side effects, but current clarity is high.

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 key action and output details. Every sentence adds value 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?

No output schema exists, but description sufficiently describes return fields. Among many sibling tools, this description is adequate for a simple list operation; could elaborate on ordering or pagination but not necessary.

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?

Tool has no parameters with 100% schema coverage. Description adds no parameter details, which is acceptable; baseline 4 is appropriate as schema already covers all.

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 explicitly states the tool lists all saved sessions and specifies the returned fields (session names, entry counts, timestamps). It distinguishes from sibling tools like load_session or delete_session by focusing on discovery and listing.

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 gives a clear use case: 'discover what context is available from previous conversations.' It implies when to use it, but does not explicitly mention when not to use it or compare to alternatives like search_context.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It reveals a meaningful behavioral trait: summaries are derived from the file's own head (frontmatter description, title plus first sentence, or module docstring), and it exposes the status dimension (found/missing). It does not explicitly state that listing is read-only, but 'List' strongly 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 with no filler. It front-loads the core action and output, packs the summary-composition rule into a parenthetical, and ends with a clear directive for downstream use. 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 there are no parameters and no output schema, the description fully covers what an agent needs: the scope ('all knowledge sources indexed by ContextEngine'), the exact fields returned (one-line summary, status, chunk counts), the summary heuristic, and the recommended next step. Nothing essential is missing for a listing 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 tool has zero parameters, so there is nothing the description needs to add about parameter meaning. The baseline for zero-parameter tools is 4, and the description appropriately focuses on output rather than inventing parameter details.

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: 'List all knowledge sources indexed by ContextEngine.' It also details the output contents (one-line summary, status, chunk counts), making the tool's purpose concrete and immediately distinguishable from the sibling read_source, which presumably retrieves a single source.

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 clear usage context: 'Read the summary to pick the right source before calling read_source.' This effectively tells an agent when to use list_sources as a precursor to read_source. It does not explicitly cover when not to use it or mention other alternatives such as search_context, 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 provided, so description must disclose behavior. It confirms load is read-only by stating 'Load' and 'Returns' without mentioning side effects. However, it does not clarify if loading activates the session or causes any internal state changes beyond retrieval, leaving some 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?

Two sentences: first defines purpose and output, second provides usage guidance. No wasted words, front-loaded with essential information. Perfectly 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?

Tool has no output schema, so description must compensate. It states 'Returns all stored key-value entries with timestamps' but lacks specifics on format, structure, or error handling (e.g., session not found). Coverage is adequate for basic understanding but not fully complete given the absence of 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 coverage is 100% and parameter 'session' is already described as 'Session name to load' in the schema. Description adds minimal extra meaning ('by name' and context hint). Baseline score of 3 is appropriate as 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?

Description clearly states 'Load a previously saved session by name' and specifies output 'Returns all stored key-value entries with timestamps'. The verb 'load' combined with resource 'session' is specific, and the usage hint distinguishes it from siblings like save_session, delete_session, and list_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?

Explicitly advises 'Use at the start of a session to restore context from a previous conversation'. Provides a clear when-to-use scenario. Does not explicitly state when not to use or mention alternatives, but the sibling list implies other session management tools for different purposes.

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 indicates a read operation but lacks details about side effects, size limits, or return format. The behavioral disclosure is minimal.

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 is front-loaded and directly states the purpose without 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 the simplicity (1 parameter, no output schema, no annotations), the description is fairly complete. It explains the primary function but could mention what 'full content' entails (e.g., plain text, structured data).

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 description does not add meaning beyond the schema's parameter description. 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 clearly states the verb ('Read'), the resource ('knowledge source'), and the method ('by name'). It effectively distinguishes from sibling tools like list_sources and search_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 does not explicitly state when to use this tool versus alternatives. The usage context is implied from the sibling tool names, but no direct guidance is 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 exist, so the description must disclose behavior. It states the action is a 'force' operation and affects all knowledge sources, implying potential resource intensity. However, it does not mention whether it is synchronous, reversible, or requires permissions. Adequate but not exhaustive.

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

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

The description is two concise sentences with zero wasted words. It is front-loaded with the action and immediately followed by usage context.

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 no parameters and no output schema, the description covers purpose and usage context. It could mention expected return or side effects (e.g., 'may take time'), but is largely complete given the tool's 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?

The tool has zero parameters; schema coverage is trivially 100%. With no parameters, the description cannot add parameter-level meaning, but it does not need to. Baseline is 4 for zero-parameter tools.

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 ('Force a full re-index') and clearly identifies the resource ('all knowledge sources'). It distinguishes itself from siblings, none of which describe re-indexing.

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 for when to use the tool: 'after adding new files or changing contextengine.json'. While it doesn't mention when not to use, the tool is singular in purpose with no clear alternatives among siblings.

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

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

Annotations are absent, so the description must disclose behavioral traits. It states the tool 'runs checks' and returns a plan, but does not indicate whether it is read-only, modifies state, or requires specific permissions. No side effects are mentioned.

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 with the main action. It efficiently lists checks in one paragraph without redundancy. Minor improvement could be bullet points for readability, but it is not overly verbose.

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 of the tool (multiple checks, structured output), the description lacks detail on the return format, error handling, and prerequisites. No output schema exists to supplement, leaving agents with insufficient context for reliable usage.

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 a well-described enum for 'scope'. The description adds value by listing all checks, which contextualizes the scope values (e.g., 'all' includes port conflicts, git remotes, etc.), enhancing semantic understanding beyond the schema's brief descriptions.

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: 'Run the Compliance Agent audit across all projects.' It lists the specific checks performed and mentions the return type, making it highly specific and distinct from sibling tools like check_ports.

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

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

No explicit guidance on when to use this tool versus alternatives like audit_verify or check_ports. The scope parameter provides some implicit usage context, but the description lacks direct comparisons 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?

With no annotations, the description carries full burden. It discloses that learnings persist forever, are updated in place on duplicates, and auto-surface in search_context. This covers key behaviors beyond the basic create operation, though it could mention deletability (inferred from sibling delete_learning) and immediate 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 three sentences with no extraneous content. The first sentence states the core purpose, the second contrasts with sessions, and the third covers duplicate handling. Every sentence is essential and the information is 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?

For a simple save operation with no output schema, the description covers the essential aspects: what is saved, permanence, duplicate behavior, and integration with search_context. It could mention category enum or that learnings are immediately available, but these are either in the schema or implied. Overall, it 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?

Schema description coverage is 100%, so baseline is 3. The description adds value by revealing that the combination of 'category' and 'rule text' determines duplicate detection and triggers update-in-place behavior. It also clarifies project is optional with an example, going beyond the schema's 'description' field.

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 saves a permanent operational rule learned during a coding session, distinguishing it from sessions which are ephemeral. The verb 'save' and resource 'permanent rule' are specific, and the contrast with sibling 'save_session' makes 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 description explicitly contrasts with sessions ('Unlike sessions (ephemeral'), guiding when to use this tool over save_session. It also explains that learnings auto-surface in search_context, indicating their use for AI agents. While not exhaustive, it provides clear context 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?

No annotations are provided, so the description carries full burden. It discloses key update behavior ('Keys are updated in place if they already exist') and mentions multiple keys per session, but lacks details on persistence guarantees, auth requirements, or potential 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 two sentences long, front-loaded with the action, and every word earns its place. It efficiently conveys purpose, usage, and key behavior without 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 three-parameter tool with no output schema and no annotations, the description is fairly complete. It explains the key-value nature, session creation, and typical use cases. Minor omissions (e.g., return value, limits) prevent a perfect score.

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 documents all three parameters (100% coverage). The description adds value by providing examples for session name and value, clarifying that sessions are created if they don't exist, and that values can be various content types. This exceeds baseline 3.

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: 'Save a key-value entry to a named session.' It specifies the action (save), the resource (key-value entry in a session), and provides examples of usage (persist decisions, context, plans). This distinguishes it from sibling tools like load_session, delete_session, etc.

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 to use it 'to persist decisions, context, plans, and findings between coding sessions,' which provides clear context. However, it does not explicitly mention when not to use it or compare it directly to alternatives like save_learning, leaving some ambiguity.

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 at all, the description carries the behavioral transparency burden, and it does a solid job by listing exactly what is inspected and what is returned. It explicitly states the return value: 'letter grade (A+ to F) with detailed breakdown'. It does not explicitly say whether the operation is read-only or whether it can modify anything, but the analysis-oriented language ('checks', 'scores', 'returns') makes the behavior reasonably clear.

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

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

The description is front-loaded with the core action and then delivers every detail in compact, scannable lists. Each sentence earns its place: the scoring target, the checked categories, and the output format. No filler or repetition.

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, no annotations, and no output schema, the description is nearly complete: it explains the input, the criteria being evaluated, and the output grade with breakdown. Minor gaps are the lack of an explicit read-only/no-side-effects statement and no mention of error conditions or prerequisites, but an agent can confidently invoke the tool with the information provided.

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 the single optional 'project' parameter as a name or absolute path and notes that omitting it scores all projects. The main description repeats the 'one or all' idea but adds no parameter semantics beyond what the schema provides. 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 opens with a specific verb and resource: 'Score one or all projects on AI-readiness (0-100%)'. It then enumerates the exact dimensions checked (documentation, infrastructure, code quality, security), which makes the tool's identity unambiguous. Even without naming siblings like run_audit or audit_verify, the detailed rubric clearly distinguishes this tool.

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

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

The description implies when to use the tool: whenever an AI-readiness score for one or all projects is needed. It also communicates the key invocation choice via 'Omit to score all projects'. However, it never explicitly contrasts this with sibling tools or states when NOT to use it, so the usage guidance is implied rather than explicit.

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. It discloses the search method (hybrid BM25 + semantic), temporal decay, and return format (chunks with source, section, line numbers). No contradictions, but could mention potential limitations like rate limits or authentication needs.

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: first sentence defines purpose and scope, second adds method and output details. Every word contributes value; 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?

Given no output schema, the description explains return format (chunks with source, section, line numbers). It lacks mention of pagination or whether results are exhaustive, but for a search tool this 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?

Schema has 100% coverage, so baseline is 3. The description adds overall context for the 'query' parameter but does not significantly augment the existing parameter descriptions for 'top_k' and 'mode'. The mention of hybrid search parallels the mode enum.

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 verb ('search'), resource ('all indexed project knowledge'), and scope (includes copilot-instructions, skills docs, runbooks, session docs). It differentiates from sibling tools that list or read specific 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?

The description implies usage for finding relevant knowledge across projects but does not explicitly state when to use this tool versus alternatives like list_sessions, read_source, or search-specific siblings. No direct comparison or exclusions are given.

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