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

No annotations are provided, so the description carries the full behavioral burden. It discloses the selection algorithm and the special rule that the highest-ranked failed-attempt warning is reserved first, but it omits side effects, return behavior, error conditions, and whether the operation is purely read-only.

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 compact sentence with no obvious filler, and it front-loads the core mechanism before the special reservation rule. The dense jargon and engine name make it slightly less accessible, but the structure is otherwise 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?

For a non-trivial optimization tool with four parameters and no output schema, the description is too sparse. It does not explain the expected return shape or edge cases such as what happens when the required warning cannot fit within the budget.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds only a small amount of meaning by indicating that the required index corresponds to a highest-ranked failed-attempt warning that is reserved first, without further clarifying costs, values, or budget.

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

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

The description names a specific resource and mechanism: it selects context chunks via an optimal 0/1 dynamic-programming knapsack method. It is clear what the tool does at a technical level, though it does not distinguish itself from any sibling tool by name or scope.

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

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

No guidance is given about when to use this tool versus alternatives, nor about prerequisites or exclusions. The only conditional behavior mentioned, reserving the failed-attempt warning first, is an internal rule rather than usage guidance.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It mentions 'erase' but does not disclose whether the erase is permanent, what data is removed, whether it requires permissions, or what side effects occur. 'Surgically' and 'Gated DeltaNet-2 pure erase gate' are flavor/implementation detail rather than actionable transparency.

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

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

One short sentence, front-loading the action and resource. The trailing 'using the Gated DeltaNet-2 pure erase gate' is technical flavor that does not help an agent invoke the tool, but the overall length is 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?

For a destructive, no-annotation tool with no output schema, the description is incomplete: it omits irreversibility, confirmation requirements, and side effects. The schema covers the key parameter, but the safety context an agent needs before erasing memory 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% and the single parameter 'key' is already documented as 'Key to erase.' The description adds no additional syntax, format, or constraint details beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('erase') and resource ('key from neural memory'), making the action clear. It does not explicitly name sibling alternatives like cortex_memory_remember or cortex_memory_recall, so it lacks the sibling differentiation that would earn a 5.

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

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

The phrase 'obsolete key' gives a vague condition for use, but there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as cortex_memory_remember or recall. Usage must be inferred.

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 behavioral burden. It usefully discloses a performance trait (<100 microseconds) and the memory type, but says nothing about miss behavior, permission/scope requirements, or confirmation that this is a safe 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?

A single front-loaded sentence with zero waste; the action, target, source, and performance trait are all delivered compactly.

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 read tool with no annotations and no output schema, the description covers the essentials, but it omits what happens when nothing matches and whether the lookup is scoped or permissioned.

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 a single documented parameter, so the baseline is 3. The description hints that the query can be a key or semantic concept but adds no format, matching, or syntax detail beyond the schema.

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

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

States a clear verb (Recall) and resource (persistent fact or project rule) drawn from a named store (associative neural memory). It is distinguishable from cortex_memory_remember and cortex_memory_erase by verb, though it does not explicitly differentiate itself from the other lookup siblings.

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

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

The phrasing implies when to reach for this tool (retrieving stored facts/rules), but there is no explicit when-to-use versus alternatives like cortex_symdex_lookup or cortex_prompt_lookup, and no when-not guidance 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 must carry the full behavioral burden. It does disclose two valuable traits: the write is persistent and the overwrite is 'clean' (idempotent upsert rather than an error on duplicate keys), plus the backing store. It omits scope/namespace, whether the value fully replaces prior content, and any permission or size constraints.

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

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

A single front-loaded sentence that leads with the action and scope. No filler, 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 mutation tool with no annotations and no output schema, the description covers the core behavior (persistent upsert) but leaves gaps: no return/confirmation semantics, no scoping model, and no guidance on the undocumented category parameter. Adequate but not 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 coverage is 67%: key and value are documented in-schema, while category has only a default ('architecture') and no description. The phrase 'architectural fact or project rule' hints at what category values might be, but the description does not explain the category parameter or the key format.

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?

Names a specific verb pair (store/overwrite) and resource (persistent architectural fact or project rule), and the 'remember' framing clearly positions it against the recall/erase siblings. It stops short of explicitly differentiating itself from siblings like cortex_symdex_lookup or cortex_sieve_compact.

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 statement of when to use this tool versus cortex_memory_recall, cortex_memory_erase, or the other memory siblings. The only usable signal is the implied upsert ('store or cleanly overwrite'), which is behavioral rather than a selection guideline.

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

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

With no annotations, the description carries the full burden, but it only hints at algorithm ('greedy') and output nature ('drafter'). It omits whether the call is read-only, what gets returned (draft tokens? counts?), latency or budget semantics, and how the required 'tokens' input should be sourced. 'Parameter-free' actively obscures the fact that parameters are required.

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?

It is a single, front-loaded sentence with no filler, which is structurally efficient. However, the compression comes at the cost of clarity, packing three unexplained terms into one line rather than using the space to inform.

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 3-parameter tool with no annotations and no output schema, the description is too thin: it doesn't define the two undocumented parameters, the output, or when to select it over neighbors. The agent lacks enough to invoke it correctly.

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

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

Schema coverage is only 33% — max_ngram and draft_budget have no descriptions at all. The description's mention of 'trailing n-gram windows' loosely relates to max_ngram but never explains it, nor does it clarify draft_budget. It fails to compensate for the low schema coverage.

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

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

The description names a specific function (greedy prompt-lookup speculative token drafting via trailing n-gram matching), so a domain-knowledgeable agent can grasp the intent. However, it is dense with unexplained jargon ('mojond engine') and doesn't differentiate itself from siblings like cortex_symdex_lookup. 'Parameter-free' is also confusing since the schema requires a 'tokens' argument.

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

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

No when-to-use guidance is given: nothing says this should be called for drafting/speculation versus the sibling lookup or memory tools, and no prerequisites or invocation context are stated. The agent must infer usage entirely from the technical label.

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

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

With no annotations, the description carries the full burden, and it does disclose the three evaluation dimensions, which is meaningful behavioral context. But it says nothing about what the evaluation produces (a verdict? a block? a score?), whether the call is side-effect-free, or what happens on a hazardous result.

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

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

A single front-loaded sentence with zero filler; the purpose and the checked dimensions arrive immediately. It is well-sized for a two-parameter tool, though it is arguably under-developed rather than padded.

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

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

With no annotations and no output schema, the description is the sole source of behavioral information, and it leaves the return contract and the consequence of a failing forecast unstated. For a safety-gating tool this is a noticeable gap, though the core purpose is 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?

Schema description coverage is 100%, so the schema already documents both 'goal' (active task objective) and 'action' (proposed command). The description adds no format or syntax detail beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description uses a specific verb ('Evaluate') on a specific resource ('candidate shell command or action') and enumerates the three checks (goal alignment, cyclic loops, destructive hazards), so an agent can tell it apart from the memory/snapshot/context siblings. It stops short of naming any sibling for contrast, which keeps it from a 5.

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

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

The phrase 'before execution' implies the correct moment to call it (pre-flight on a proposed action), which is genuine usage context. However there is no explicit when-not guidance and no named alternative, so the guidance remains implied rather than stated.

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

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

With no annotations, the description carries the full burden. It discloses a key behavioral trait: it retains all stack traces and errors, which is critical for an agent to know the compaction is lossy but safe for debugging. However, it doesn't mention other potential behaviors like idempotency 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?

Single, efficient sentence that front-loads the action, target, and benefit. No redundancy or filler.

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

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

Given the tool's simplicity (2 parameters, no output schema, no annotations), the description covers the core purpose and one behavioral trait. However, it fails to explain the 'max_lines' parameter or any edge cases, leaving gaps for an agent to call it correctly.

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

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

Schema description coverage is only 50%, so the description must compensate. It does not describe the 'max_lines' parameter or its effect on the output, nor does it explain the 'raw_text' input beyond what the schema already says. The description adds no parameter-level detail beyond the schema.

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

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

States a specific verb (Compact), resource (terminal logs or test outputs), and quantifies the effect (90-98%). Clearly distinguishable from siblings like cortex_context_pack or cortex_prompt_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?

Implies usage context (verbose terminal logs, test outputs) but does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that snapshots are deduplicated and copy-on-write (implying cheap, low-storage checkpoints), which encourages frequent use. But it says nothing about required permissions, what the call returns, or how the created snapshot is later referenced, so significant gaps remain.

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?

One sentence, front-loaded with the action, with every clause earning its place (what is created, how it is implemented, and when to call it). There is no filler or redundancy.

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

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

For a snapshot-creation tool with no annotations, no output schema, and one optional param, the description covers the what and the when. It omits the natural lifecycle linkage to cortex_snapshot_rewind (how to restore) and any indication of the returned handle, which an agent would need to use the snapshot afterwards.

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

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

Schema description coverage is 0% and the description never mentions the single 'label' parameter, so it adds no semantic detail. The impact is limited because the parameter is optional with a sensible default ('Agent pre-edit checkpoint'), keeping the stakes low, but the description does not compensate for the coverage gap.

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

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

The description gives a specific verb and resource ('Create a ... workspace snapshot') with meaningful qualifiers ('deduplicated copy-on-write'), so an agent knows exactly what operation this is. It does not explicitly name the complementary sibling cortex_snapshot_rewind or contrast itself against it, which keeps it at 4 rather than 5.

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

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

It supplies a concrete trigger condition: invoke this 'before executing risky multi-file edits.' That is real usage guidance, not just a restatement of purpose. However, it offers no explicit exclusions (e.g., when a snapshot is unnecessary) and no named alternative, so it falls short of 5.

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

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

With no annotations, the description carries the full behavioral burden. It does add two meaningful traits beyond the schema: the operation is 'atomic' (all-or-nothing) and it does not touch .git history. But it is silent on whether this is destructive, what happens to current uncommitted workspace state, reversibility, and permission requirements.

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

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

A single front-loaded sentence with no filler; the verb and scope constraint are stated immediately and every clause carries information.

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

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

For a mutation-style tool with no annotations and no output schema, the description is thin: it does not disclose destructiveness, reversibility, or the fate of current workspace state. The atomicity and .git-exclusion notes help, but an agent still lacks key facts for safe 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?

There is a single parameter with 100% schema description coverage, so the schema already documents snapshot_id including an example format. The description adds nothing about the identifier, 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?

States a specific verb (rewind) and resource (workspace to a previous snapshot), with a useful scope qualifier that the operation leaves .git history untouched. It is clearly distinguishable from cortex_snapshot_create, though it never names that sibling explicitly.

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 phrase 'without altering .git history' implies this is the tool to use when you want to restore workspace state without a git-based reset, which is a reasonable implied usage cue. However, there is no explicit when-to-use, when-not-to-use, prerequisite, or alternative named, so the agent must infer the boundary.

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

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

With no annotations, the description carries the full burden, and it discloses useful behavior beyond the schema: sub-150-microsecond lookup that avoids reading full files, which is read-only by implication. However, it says nothing about match semantics (exact vs fuzzy), result ordering, or what happens when nothing matches, so the disclosure is only partial.

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

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

A single front-loaded sentence with no wasted words. The performance claim ('<150 microseconds without reading full files') is the one slightly promotional phrase, but it doubles as a behavioral hint, so it 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?

With no output schema and an undocumented second parameter, the description should compensate but does not: it omits return shape, match semantics, and any usage guidance. For a lookup tool in a large sibling set, this leaves the agent with meaningful gaps.

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

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

Schema coverage is only 50%: 'query' is documented in the schema, but 'top_k' has no schema description and the description never mentions it, so its meaning (number of definitions returned?) is left entirely to inference. The description adds no parameter meaning at 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?

States a specific verb (Locate) and resource (function, class, struct, or interface definitions) with a clear scope ('across the codebase'). It is distinguishable from the memory/snapshot siblings, though it never explicitly names or contrasts with the nearest sibling, cortex_prompt_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 implies usage ('locate definitions') but gives no when-to-use context, no exclusions, and no alternative tool to prefer in other cases. An agent must infer entirely when this is the right call versus cortex_prompt_lookup or cortex_context_pack.

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