cellmath

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

With no annotations, the description carries the full burden and does deliver real signal: the '[PUBLIC WRITE]' tag flags a mutating, publicly visible operation, and 'index it in the sidecar database' discloses a non-obvious side effect. It stops short of stating whether the move is reversible, whether the original proposed cell is removed, or what permissions/confirmation are needed.

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 the write-scope tag first and the action second; every clause carries information. The bracketed '[PUBLIC WRITE]' convention is slightly opaque but compact and useful.

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

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

For a two-parameter mutation tool with no annotations and no output schema, the description covers the core action and one side effect but omits state preconditions, failure behavior, and what the caller receives back. Adequate to attempt a call, thin for calling it confidently.

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% — both 'id' (cell ID to accept) and 'folder' (folder path) are documented in the schema, so the baseline of 3 applies. The description adds nothing about parameter meaning, e.g. whether 'folder' must be the source or destination location.

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 (move) plus the exact resource transition (proposed cell → accepted cells) and the secondary effect (indexing in the sidecar database). An agent can distinguish this from generic cell creation, though the complementary sibling 'reject' is never named.

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

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

Usage is only implied: the 'proposed → accepted' framing suggests this is the approval step for a pending cell, but there is no explicit when-to-use, no prerequisites (must the cell be in 'proposed' state?), and no pointer to 'reject' as the alternative path.

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?

Discloses several behavioral traits: enforcement of preflight verification, anti-dogma checks, temporal date validation, and requirements for ai_compressed_summary or clean content. It does not fully explain side effects (e.g., whether it overwrites existing items) or success/error behavior, but without annotations it carries the burden well.

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?

Front-loads the core purpose with a bracketed protocol label, then presents numbered rules. The structure is efficient for an 11-parameter tool, though the header '[STANDARDIZED WRITE PROTOCOL - PRIVATE MODIFY]' is somewhat opaque and could be clearer.

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

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

For an 11-parameter write tool with no annotations and no output schema, the description covers key validation and promotion rules but omits important context: what the tool returns (e.g., created item ID), how it handles existing items, and what 'PRIVATE MODIFY' entails. Adequate but with clear gaps.

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

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

Schema description coverage is 91%, so the schema already documents most parameters. The description adds meaningful context linking parameters: it clarifies that user_confirmed is required for fact/cell promotion and that ai_compressed_summary or clean content is essential, which is not fully captured in 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?

States a specific verb (Store) and resource (verified item in the knowledge vault), distinguishing it from read siblings like get_knowledge_item. However, it does not explicitly differentiate itself from other write siblings such as create_cell or ingest.

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

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

Provides rules for fact/cell promotion (requires citation tag or user_confirmed) and mentions preflight verification, implying usage for verified knowledge items. But it lacks explicit when-to-use/when-not-to-use guidance relative to sibling tools like create_cell or ingest.

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 key traits: write operation, public access class, persistence target (.braincell/map.jsonl), a cloud-sync side effect, and the guarantee that node files stay untouched. It omits validation/idempotency behavior (what happens if the edge already exists), error conditions, and what the call returns.

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 opening with the access/write class marker, then verb, resource, storage location, and the non-mutation guarantee. Zero filler.

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

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

For an annotation-free mutation tool with no output schema, the description covers where data lands and what it does not touch, which is the critical part. It still leaves the agent guessing about duplicate handling, whether the inverse edge is auto-created, and any acknowledgment returned, so it is 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 description coverage is 100%, so all four parameters are already documented in the schema; the description only re-implies 'link' semantics through 'from'/'to' wording. It adds nothing about the optional 'inv' inverse-relation parameter or whether the relation is directed.

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 verb ('Append') and resource ('a new decoupled link to the map ledger'), plus the concrete artifact path (.braincell/map.jsonl). It differentiates itself from the read counterpart read_map_links by verb alone, but 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?

'decoupled link ... without modifying node files' implies the use case (adding a relation without touching node content), which is useful implied guidance against mutation alternatives like modify_cell_configuration. However, there is no explicit when-to-use/when-not statement, no mention of read_map_links as the lookup counterpart, and no guidance on duplicates or re-adding an existing edge.

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 behavioral burden. It helpfully labels the tool as a PUBLIC WRITE and discloses the tri-tier outcomes tied to Kappa ranges, but it does not clarify permissions, reversibility, or exactly what is written or committed in the Auto-Commit case.

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

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

The description is a single front-loaded sentence that starts with the PUBLIC WRITE classification and then gives the core purpose and thresholds. It is efficient, but the dense jargon around '4-choice conflicts' and '7-turn queries' reduces immediate readability.

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

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

For an 8-parameter arbitration tool with no annotations and no output schema, the description covers the operating condition and Kappa decision tiers but leaves the return behavior and side-effect semantics underspecified. It is workable, but an agent still lacks enough detail to know exactly what the arbitration call produces or commits.

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 useful meaning for kappa by mapping score ranges to concrete arbitration outcomes, and it implicitly links conflict-resolution and seven-turn modes to the corresponding flags, though it does not explain target_id, confidence, or token_estimate.

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 decision domain: arbitrating actions, conflicts, and 7-turn queries under Kappa thresholds when a human is unattended/headless. It is clearly a gate/arbitration tool rather than a generic verify or accept/reject tool, though it does not explicitly distinguish itself from nearby siblings such as verify_action_safety or accept/reject.

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 gives a clear triggering condition: use when the human is unattended or headless. However, it does not name alternatives or state exclusions, so an agent must infer when verify_action_safety, accept, or reject would be more appropriate.

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

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

With no annotations, the description carries the full burden. It discloses that this is a write operation that scans all cells and mutates the hierarchy into Organs and Human evaluator nodes, but it omits irreversibility, required permission level, side effects, and what happens to existing structures.

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 write classification and the core purpose. Every sentence contributes useful information without repetition 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?

There are no annotations and no output schema, so the description must compensate for missing behavioral detail. For a high-impact write tool that scans all cells and changes hierarchy, the description is too thin on prerequisites, safety implications, and expected outcomes to be 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%, and the single authKey parameter is documented in the schema as 'User or admin auth key.' The description does not add meaning about authKey usage or the public/private distinction beyond the tag, 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?

The description uses a specific verb and resource: 'Run full auto-evolution & clustering cycle,' then explains the scan and clustering into Organs and Human evaluator nodes. It is clear what the tool does, but it does not explicitly distinguish itself from siblings like promote_to_organ or create_human_node.

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?

There is no guidance on when to use this tool versus alternatives such as check_evolution_readiness, promote_to_organ, or execute_dytopo_round. The '[PUBLIC/PRIVATE WRITE]' tag implies a write operation, but no prerequisites, exclusions, or selection conditions are 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. Its only behavioral cue is the ambiguous "[PUBLIC READ/WRITE]" tag; it does not state whether the calculation is pure/read-only, whether it has side effects, or what permissions are needed.

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

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

The description is a single front-loaded sentence with no padding. The bracketed "[PUBLIC READ/WRITE]" tag is vague but very brief, so it does not significantly hurt conciseness.

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 schema documents both inputs and the description names the outputs, which is minimally adequate for a low-complexity calculation tool. However, with no annotations and no output schema, it should clarify the optional-parameter selection and return format more explicitly.

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

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

Schema description coverage is 100%, so the schema already explains both parameters and the baseline is 3. The description adds no parameter-level meaning beyond the schema, such as when to use text versus probabilities or whether one of the optional inputs must be supplied.

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: calculating Shannon entropy, state uncertainty, and Information Gain ratio. It is clear enough to distinguish the metric from calculators like calculate_wasserstein_distance, but it does not explicitly differentiate itself from the many other math-computation 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?

There is no guidance on when to use this tool versus compute_math_expression, solve_symbolic_matrix, or calculate_wasserstein_distance. It also does not say whether callers should provide text, probabilities, or both, which is important because neither parameter is required.

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, yet it only adds an ambiguous '[PUBLIC READ/WRITE]' access tag — odd for what is evidently a pure computation. It does not say whether the distance is symmetric, whether inputs must be normalized/same length, how costs are handled, or what is returned.

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

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

A single, tightly front-loaded sentence with no filler; the access tag leads and the purpose follows. Nothing is wasted, though the brevity comes at the cost of missing constraints.

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

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

No output schema exists, so the description should at minimum state that a scalar distance is returned and describe input constraints such as equal length or normalization. Neither is present, and with zero annotations the definition is not sufficient to call the tool confidently.

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 parameters as distribution/embedding vectors. The description adds only that the inputs are expected to be probability distributions, which implies normalization but does not state it explicitly or address differing lengths/weights.

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 ('Compute') and a specific metric ('Wasserstein-1D optimal transport distance') over a named resource (state probability distributions). It is clearly distinguishable from siblings such as calculate_entropy_gain and compute_math_expression, though it never explicitly contrasts itself with them.

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?

There is no statement of when this metric is the right choice versus alternatives like calculate_entropy_gain, no prerequisites, and no exclusions. The phrase 'between state probability distributions' only hints at the intended input domain.

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, yet it only lists internal mechanisms rather than operational traits. It never states what happens when verification fails (error vs. low-confidence result), whether the call mutates state, whether authKey is mandatory, or what the response contains.

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 compact sentence, so it is not verbose, but token efficiency is poor: most of the clause is opaque branding that does not help an agent decide or act. Front-loading is acceptable ('verification engine'), yet the payload is diluted.

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 5-parameter tool with no annotations and no output schema, the description should explain the result shape (pass/fail, score, confidence) and the role of authKey and context_nodes. Neither is addressed, leaving the agent unable to predict what comes back.

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

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

Schema coverage is 100%, so the baseline is 3. The description reinforces the κ>=0.98 threshold and vaguely ties '15-creativity process divergence filtering' to creativity_process_index, but adds no usable semantics beyond what the schema already documents.

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 core verb+resource ('mathematical axiom and hypothesis verification engine') is identifiable and does distinguish it from siblings like verify_action_safety and verify_braincell_status. However, the sentence is buried under unexplained jargon (Kappa gate, Softmax tail-error suppression, DyTopo routing), so an agent must decode branding to grasp what it actually does.

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 indication of when to reach for this tool versus compute_math_expression, execute_cell_math, solve_symbolic_matrix, or execute_dytopo_round, all of which live in adjacent territory. There are no exclusions, prerequisites, or triggering conditions 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 must carry behavioral disclosure. It does convey the compaction behavior and token-cap intent, and the tri-state (forget/store/retain) is named. However, it does not state whether compaction discards raw messages irreversibly, what happens to retained KV on forget, or any permission requirements — meaningful gaps for a state-mutating memory 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?

Only two sentences, but both are dense with bracketed tags, capitalized jargon, and acronyms (MASTER_SLIM, Organ, Node 1) that crowd out the core action. The essential 'compresses the session' idea is present but not cleanly 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?

No output schema and no annotations, so the description should ideally explain the returned package and side effects. It gestures at the '4-pack minimal context package' output but doesn't clarify its structure or what the caller receives on forget versus retain, leaving gaps for a 4-parameter mutation 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 all four parameters (including the forget/store/retain enum) are already documented in the schema. The description adds the 7-turn threshold context but nothing about target_node_id or context_messages semantics beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb and resource: compresses the active session into a defined 4-pack context package. The bracketed labelling and token-savings metric make the action concrete. It distinguishes itself from siblings like get_session_handover_package by being a compactor rather than a fetcher, though the jargon reduces immediate legibility.

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 'Strict 7-Turn Window' framing implies the trigger condition (echoed by the turn_count schema note '>= 7'), but the description never explicitly states when to call this versus alternatives such as clear_kv_cache_memory or get_session_handover_package. Usage is inferable but not spelled out.

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 present, the description carries the full burden; '[PUBLIC READ]' usefully discloses that this is a non-mutating, public read operation, which is real value. However, it says nothing about side effects, whether the check is expensive, or whether authKey is needed versus optional (the schema marks zero required parameters).

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 compact sentence with the access-level tag front-loaded, so the safety signal is seen first. No filler, though the vocabulary is dense domain jargon that assumes familiarity with Organs and the Human evaluation layer.

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?

There is no output schema and no annotations, so the description should say roughly what a readiness result looks like (counts, lists, boolean flags), but it does not. For a short read-only check the bar is low, yet the undefined domain terms leave the return shape entirely to inference.

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

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

Only one parameter and schema description coverage is 100%, so the schema already documents authKey as an optional 'User or admin auth key'. The description adds no semantics about how auth level changes results, 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?

Uses a specific verb ('Check') plus a precisely scoped resource: clusters ready for Organ promotion and Organs ready for the Human evaluation layer. This is distinguishable from promote_to_organ (which performs promotion) and auto_evolve_hierarchy (which acts on hierarchy), though it never names those siblings directly.

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 'ready for Organ promotion' implies this is a pre-flight check before calling promote_to_organ, but no explicit when/when-not guidance or alternative is stated. The '[PUBLIC READ]' tag hints at a safe inspection step, yet nothing tells the agent when this check is required versus optional.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that this is a 'PRIVATE MODIFY' operation and that it should not impact static policies, which is useful scope information. Still, for a destructive 'Purge' tool, it omits key details such as irreversibility, required permissions, and what happens if the pattern accidentally matches non-test artifacts.

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 focused sentence with no redundant padding. It is front-loaded with the action and scope, though the bracketed internal tag and unexplained '(Item 13)' slightly reduce immediate understandability.

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

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

For a tool with no annotations, no output schema, and a single simple parameter, the description covers purpose and scope boundaries but leaves out behavioral safety details that an agent would need before invoking a destructive cleanup operation. It is adequate but has clear 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?

The schema has 100% description coverage for its single 'pattern' parameter, so the baseline is 3. The description does not add any parameter-specific guidance, but the schema already explains the optional keyword/pattern and its default value, so no compensation is required.

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 ('Purge') and names the exact resources: benchmark test residues, temporary probe nodes, and volatile test artifacts. It clearly distinguishes the cleanup scope from static policies. The only weakness is the unexplained internal tag '[PRIVATE MODIFY]' and '(Item 13)', which add ambiguity rather than clarity.

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

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

The description implies when to use it: cleaning up test-related artifacts while leaving static policies untouched. However, it does not explicitly state when not to use it, mention alternatives, or discuss prerequisites such as confirming that the matched items are truly disposable.

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 does disclose the two most important traits for a destructive operation: exactly what is removed (personal session items) and what survives (static system invariants, other users' items). It omits reversibility/recovery and any auth or confirmation 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?

Two tight sentences, front-loaded with the operation class, and every clause adds information (what is cleared, what is kept). No filler.

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

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

For a destructive tool with zero annotation coverage and no output schema, the description covers blast radius but not irreversibility, required privileges, or what the call returns. Adequate to select the tool, thin on what happens after invocation.

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

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

Schema coverage is 100%, so both parameters are already documented in structured fields. The description only loosely gestures at them ('your personal session items', 'system invariants preserved') without explaining ownerId namespace scoping or the effect of setting preserveBasePolicies to false.

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 (clears) and a precisely scoped resource (personal session items in the KV Prompt Cache), plus the [PUBLIC WRITE] tag signals the operation class. It implicitly separates itself from siblings like get_kv_cache_item/put_kv_cache_item by scope, though it never names them.

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 preservation clause hints at when this is appropriate (you want to clear session state without disturbing invariants), but there is no explicit when-to-call, no mention of related tools, and no stated preconditions or confirmation step.

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

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

There are no annotations, so the description carries the full behavioral burden. It includes a terse '[PUBLIC READ/WRITE]' tag indicating access level, but does not explain what 'WRITE' means for a math tool, whether anything is persisted, permission requirements, or expected response behavior.

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

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

The description is a single front-loaded sentence with no filler. It is appropriately concise, though the bracketed access tag is not integrated into a fuller structure.

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

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

The purpose and supported operations are clear, and the schema fully documents parameters. However, with no annotations and no output schema, the description does not describe return values, side effects, or operation-specific behavior, leaving meaningful gaps for an agent.

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

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

Schema description coverage is 100%, so both parameters and the nested variables object are already documented in the schema. The description adds no parameter-specific meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a clear verb ('Execute') and resource ('mathematical expression') and lists supported capabilities such as symbolic polynomial evaluation, derivatives, and statistical functions. However, it does not differentiate this tool from nearby siblings like execute_cell_math or solve_symbolic_matrix.

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 on when to use this tool versus alternatives such as execute_cell_math or solve_symbolic_matrix. The description states capabilities but provides no context, exclusions, or decision criteria.

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

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

No annotations are provided, so the description carries the full burden. '[PRIVATE WRITE]' usefully discloses that this mutates state and may be access-restricted, but it says nothing about what happens on a duplicate cell_id (error versus overwrite), whether writes are atomic, how the vault versus the engine are kept consistent, or what permissions 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?

A single front-loaded sentence with the privacy/mutation tag leading, which is exactly the right place for it. It is not padded, though it is arguably too short rather than too long.

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

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

For an 8-parameter, 3-required mutation tool with no annotations and no output schema, the description omits everything an agent needs beyond field names: duplicate handling, failure modes, what is returned (e.g., whether the created cell or just an ack), and the relationship between the CellMathEngine entry and the vault entry.

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 eight parameters are already documented in the schema, including the mode and grain enums. The description adds no meaning beyond that, which is acceptable per the baseline but earns no credit.

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 verb ('Register or create') and resource ('a new skill cell unit in CellMathEngine and vault') are stated, and 'new' distinguishes it from modify_cell_configuration. But the domain terminology ('skill cell unit', 'vault') is unexplained, and no sibling tool is named, so the agent must infer the boundary from the name alone.

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?

There is no statement of when to use this versus alternatives such as add_knowledge_item, ingest, or modify_cell_configuration. The only usage signal is the '[PRIVATE WRITE]' prefix, which hints at restriction but does not say under what conditions the tool should or should not be invoked.

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

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

No annotations are provided, so the description carries the full disclosure burden. The '[PRIVATE WRITE]' marker usefully signals that this is a privileged mutation, but the description says nothing about required permissions, whether organs must pre-exist, what happens on partial failure, or whether the node is removable — significant gaps for a write tool with zero annotation coverage.

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 sentence with the write/safety marker front-loaded before the purpose, which is the correct order. Dense domain jargon slightly blunts readability but nothing is wasted.

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 5-parameter privileged mutation with no annotations and no output schema, the description should explain what the created node does, constraints on organ supervision, and what success returns. Those elements are absent, leaving the agent to guess at consequences.

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 five parameters are already documented in the schema and the baseline is 3. The description only loosely echoes 'purpose' (evaluation domain) and 'organ_ids' (supervising Organs) and adds no format or constraint 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?

Names a specific verb ('Create') and a specific resource ('Human feedback and evaluation governance node supervising Organs'), and the 'Tier: Human' tag situates it against the structural siblings like create_cell and promote_to_organ. It never explicitly contrasts itself with those siblings, but the resource noun is distinct enough that an agent can tell what it makes.

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?

There is no statement of when to use this versus create_cell, promote_to_organ, or the other hierarchy-mutating siblings, and no prerequisites beyond the '[PRIVATE WRITE]' tag. The agent must infer the usage context entirely from the name.

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 the private-schema ownership restriction and signals a destructive modification via the tag and 'Delete'. However, it does not state irreversibility, what error occurs when the item is not owned, or authentication requirements, which are the key behaviors for a delete operation.

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

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

Two short sentences with the scope tag front-loaded and zero redundant text. Every element earns its place.

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

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

For a one-parameter tool with full schema coverage and no output schema, the description covers purpose and the critical ownership scope. The main omission is irreversibility/error behavior for a destructive action, which keeps it from a 5.

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

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

Schema description coverage is 100% for the single 'id' parameter, so the schema already explains that it is the ID of the item to delete. The description adds no syntax or format detail beyond that. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description states a specific verb and resource ('Delete an item from knowledge vault') and adds an ownership scope that separates it from read/add siblings like get_knowledge_item and add_knowledge_item. The '[PRIVATE MODIFY]' tag reinforces the mutation intent. It stops short of naming a sibling explicitly, so a 4 rather than 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?

It clearly states the condition for use and the boundary: 'Restricted ONLY to items owned by your authenticated private schema.' That gives the agent a concrete exclusion (items not owned by the caller's private schema). No alternative tool is named for the out-of-scope case, which keeps it from a 5.

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

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

With no annotations, the description carries the burden and does disclose that this is a durable commit/checkpoint operation rather than a loop engine. However, it does not explain mutation side effects, reversibility, permission requirements, or what the commit returns.

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 warning is front-loaded, which helps, but the description is repetitive: it warns against repetitive loops twice and repeats CRITICAL in multiple places. The core guidance is clear, but the wording is longer and more alarmist than necessary.

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 is strong on when to invoke this tool, but with no annotations and no output schema it does not explain return behavior, write safety, or the consequences of committing to the vault. The 100% schema coverage compensates for parameter gaps, but behavioral completeness remains only 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 description coverage is 100%, so parameter meaning is already supplied structurally. The description does not add per-parameter semantics beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description explicitly redefines CellMath as a durable state commit and vault persistence tool, not a step-by-step thinking loop engine. That is a clear verb-and-resource purpose, though the tool name execute_cell_math remains semantically confusing and no sibling is named for contrast.

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

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

The description gives explicit when-to-use conditions: final verification, 7-turn checkpoint freezing, or an explicit user command. It also gives explicit when-not-to-use guidance (no repetitive loops or intermediate thought loops) and points to local text skills as the alternative.

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

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

No annotations are provided, so the description carries the full behavioral burden. The '[PUBLIC READ/WRITE]' tag hints at access scope and state mutation, but it is ambiguous (does executing a round write persistent state?), and nothing is said about side effects, idempotency, required permissions, round-sequencing constraints, or cost.

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 short sentence with the access tag front-loaded; nothing is redundant. It is efficient, though its brevity comes at the cost of substance rather than being a model of dense 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 three-required-parameter execution tool with no annotations and no output schema, the description says far too little: it does not explain what a 'round' returns, whether state is mutated, or what prerequisites must exist. An agent could not confidently invoke this correctly from the description alone.

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 all three parameters have their own descriptions, which sets the baseline at 3. The tool description adds no extra meaning about how goalTask, roundNumber, or targetEntities interact with a routing round.

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 verb ('Execute') and a named resource ('dynamic topology (DyTopo) routing round'), so the general action is identifiable. However, 'DyTopo routing round' is unexplained jargon and the description gives no indication of what the round actually does or produces, nor how it differs from the nearby sibling fcrt_route_execution, which appears to serve a similar routing purpose.

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

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

There is no statement of when to use this tool, what preconditions must hold (e.g., an existing topology, round numbering starting point), or when to prefer fcrt_route_execution or other routing-adjacent siblings instead. The agent must infer usage entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. The [PUBLIC READ] prefix is a useful hint that this is a non-mutating read, and the pseudo-code discloses that the tool branches into decode vs prefill paths. But it says nothing about side effects, determinism, required permissions, failure modes, or whether the decision is cached/persisted — internal implementation steps ('serve.get', 'engine.decode') are not caller-facing behavior.

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

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

It is a single sentence with no filler, and the [PUBLIC READ] safety tag plus the verb are front-loaded. But the middle is a compressed pseudo-code block that is hard to parse and arguably belongs in documentation rather than a tool description, so density substitutes for structure.

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

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

With 7 parameters, no annotations, and no output schema, the description must explain both behavior and return value. It gestures at a return ('-> (block, R)') and the branch taken, but does not state the actual response shape an agent would receive, nor how the 7 inputs combine. For a tool of this complexity with zero structured behavioral metadata, it is materially incomplete.

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

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

Schema description coverage is 100% (all 7 parameters documented in the schema), so the baseline is 3. The description mentions 'key' and an undefined 'cov', but does not explain the roles of model, target_t_k, u_t, salt, namespace, or guidance_ids, nor how they influence the decode/prefill decision. It adds no meaning beyond what the schema already provides.

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

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

The description states a verb and resource ('Evaluate FCRT Serving Adapter routing decision') and sketches the decision logic (serve.get → test R/cov_ok/prefix_only → decode vs prefill), so the intent is discernible. However, it is written in dense internal jargon (FCRT, cov_ok, R, prefix_only) that an agent without domain knowledge cannot map to a concrete task, and it gives no differentiation from any sibling tool such as verify_action_safety or arbitrate_unattended_weight_gate.

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?

There is no explicit statement of when to call this tool, what preconditions must hold, or which sibling to use instead. The [PUBLIC READ] tag hints at a read-only evaluation context but does not say under what circumstances an agent should invoke it versus the many other evaluation/verification tools in the sibling list.

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. The '[PUBLIC READ/WRITE]' tag is ambiguous for a retrieval tool and never explained, and the description does not say how large the graph response can be, whether depth is bounded, or what the returned structure looks like; only the token-cost hint adds any real behavioral context.

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

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

Two tight sentences with the resource identified first and the token-cost guidance second; nothing is wasted. The bracketed access tag is the only slightly noisy element.

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

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

No output schema exists, so the description should ideally sketch the return shape for a graph query, which it does only loosely. Given a simple 3-parameter, zero-required schema, it is close to sufficient but leaves the response format and the READ/WRITE semantics unexplained.

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 all three parameters are already documented, including the token-saving purpose of summary_only. The description restates that advice but adds no syntax, defaults, or interaction details (e.g., how max_depth combines with focus_node_id) 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 (Retrieve) and two named resources (knowledge synapse graph, DyTopo active communication graph), which distinguishes it from item-level siblings like get_knowledge_item or search_knowledge. The '[PUBLIC READ/WRITE]' prefix muddies rather than clarifies what the resource is.

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

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

Gives concrete guidance on which parameters to use to limit token cost ('Use summary_only or focus_node_id to minimize token usage'), but says nothing about when to choose this tool over graph-adjacent siblings such as search_knowledge, read_map_links, or get_knowledge_item. Usage is only implied.

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 does disclose meaningful behavior: this is a public read, returns full content with temporal freshness and epistemic status, and supports 304-style optimization via client_hash. It does not cover not-found behavior or authorization edge cases, so it falls short of 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?

The description is compact and front-loads the core retrieval purpose, followed by behavioral caveats. The standardized protocol label and 'zero absolute truth assumption' phrasing add some jargon, but the sentence is still 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 tool with no output schema and no annotations, the description does enough to explain what is returned (full content plus freshness and epistemic metadata) and how client_hash affects fetching. It could be more complete by noting missing-item behavior or access expectations, but it is largely sufficient.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds a small amount of context for client_hash, but does not meaningfully clarify intent or ownerId 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 states a specific verb and resource: retrieve the full content of a knowledge item, rule cell, or invariant by ID. It distinguishes itself from search-style siblings by emphasizing exact-ID retrieval, though it does not name search_knowledge as the alternative.

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

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

The description gives a clear usage hint for client_hash to avoid redundant re-fetching, but it does not explicitly say when to use this tool versus search_knowledge or other retrieval siblings. The by-ID scope implies the usage, but the guidance is not fully 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?

No annotations are provided, so the description carries the full behavioral burden. The '[PUBLIC READ]' tag and 'Retrieve' communicate that this is a read-only public lookup, but the description does not explain miss behavior, return shape, authorization expectations, or other operational details.

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, efficient sentence with the read-only nature front-loaded in brackets. Every element, including the usage context, is relevant and there is no wasted 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?

For a simple cache lookup with full schema coverage, the core purpose and context are adequately stated. However, with no output schema and no annotations, the description could better explain what is returned on a hit or miss and any important lookup constraints.

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 input schema already documents key, intent, and ownerId. The description reinforces the key-based lookup but does not add meaning for the optional intent or ownerId parameters beyond what the schema provides.

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

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

The description states a specific verb and resource: retrieve an item from the KV Prompt Cache by key. It also gives a usage context (session verification or inspection). It does not explicitly distinguish itself from nearby siblings such as put_kv_cache_item, clear_kv_cache_memory, or query_kv_cache_stats, so it is clear but not fully sibling-differentiated.

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 'for session verification or inspection' implies when the tool is useful, but there is no explicit when-not guidance and no named alternative for storing, clearing, or querying cache data. Usage is inferable but not fully directed.

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. The '[PUBLIC READ]' tag hints at read-only safety, but the description does not explain side effects, return format, error conditions, or whether it mutates state, leaving a significant gap for a tool without annotations.

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

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

The description is a single front-loaded sentence with no wasted words; the bracketed list conveys the package structure concisely. It could be slightly more structured for readability, but it is efficient overall.

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 should explain the result format and usage context. Instead, it references an external specification and lists tiers in cryptic terms, leaving the agent without enough information to call it confidently.

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 parameter meanings are already documented. The description loosely maps cursor and target_cell_id to its components but adds no syntax, format, or constraint details beyond the schema, so baseline 3 applies.

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

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

States a specific verb ('Generate') and resource ('Session Handover package') and enumerates the four tiers it produces, so an agent can tell what it does and distinguish it from siblings. However, the enumeration relies on domain jargon (MASTER_SLIM, Organ, Cell) and an external spec (HMC v1.04 Section 10), which reduces immediate clarity for a general agent.

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

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

Provides no guidance on when to use this tool versus alternatives such as cellmath_compact_session or scan_hierarchy_filesystem. There are no exclusions, prerequisites, or contextual triggers mentioned.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that access is public read and that the policies are foundational and forcefully injected, but it does not describe return format, size, or caching behavior beyond what the schema already says about client_hash.

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

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

The description is a single front-loaded sentence with a useful access tag and a compact enumeration of the policy categories. Every element earns its place.

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

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

For a simple read tool with one optional parameter and no output schema, the description is adequate: it identifies the content and public-read access. However, it does not describe the return shape or any operational details that would help an agent fully anticipate the response.

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 single optional client_hash parameter and its 304 behavior are already fully documented in the schema. The description adds no parameter-specific semantics beyond that structured documentation.

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 ('Inspect') and a specific resource ('foundational system policies'), and it enumerates the exact policy categories returned. This clearly distinguishes it from generic KV-cache retrieval siblings like get_kv_cache_item.

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 states '[PUBLIC READ]' and what the tool inspects, but gives no explicit guidance on when to use it versus alternatives such as get_kv_cache_item or query_kv_cache_stats. It also does not mention any preconditions or exclusions.

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

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

With zero annotations, the description carries the full burden, and it does disclose that this is a public, read-only inspection (the '[PUBLIC READ]' marker). It says nothing about cost, whether scores are computed on demand, result size, or the shape of the response.

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 access tag and the verb, with no filler. The density of undefined jargon slightly hurts readability but nothing is wasted.

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

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

For a zero-required-param read with no output schema, the definition covers what is inspected and the access model. The only real gap is that the domain terms ('HVS', 'recovered error stats') are unexplained for an agent unfamiliar with the system.

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 single parameter is documented in-schema as an optional module/cell ID. The description adds no meaning about how target_id scopes results or what happens when it is omitted (presumably all modules).

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?

Uses a specific verb ('Inspect') with three named payloads: localized live-scores, recovered error stats, and active unrecovered step failure labels. It is distinguishable from siblings like verify_braincell_status or hvs_query_segregated_memory, though the jargon 'HVS' and 'unrecovered step failure labels' is not defined.

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 '[PUBLIC READ]' prefix signals access level but not when to choose this over near-neighbors such as verify_braincell_status or hvs_query_segregated_memory. No preconditions, exclusions, or alternative routing are 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, and the '[PUBLIC READ]' tag usefully discloses that this is a non-destructive, unauthenticated read. However, it says nothing about what a call actually returns, whether results are ranked/limited/paginated, or how allow_episode_audit changes the safety or volume profile — meaningful gaps for a query tool with zero annotation coverage.

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

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

Two short sentences, zero filler, with the access level and the resource scope front-loaded before the constraint. Every phrase 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?

A 2-parameter read tool with a complete schema and no output schema is close to self-documenting, so this is nearly adequate. The missing piece is the query semantics themselves: the tool is called 'query' yet takes no query term or filter, and the description never clarifies that this returns a bucket rather than matching a predicate.

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 enum and the audit flag are already fully documented in the schema; the description only restates the bucket list. It adds no semantics for allow_episode_audit (e.g., why episode traces are normally withheld), which would have been genuinely additive. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb (Query) and resource (5 segregated memory type buckets) and enumerates the bucket values inline, so the agent knows exactly what domain this covers. It does not, however, distinguish itself from adjacent memory/knowledge siblings such as search_knowledge, get_knowledge_item, or get_kv_cache_item, so an agent still has to infer that this is the segmented-store reader.

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 'Prohibits accidental type mixing' implies the usage context (you must commit to one bucket rather than a broad search), which is a useful selection hint versus a generic search tool. But there is no explicit when-to-use / when-not-to-use statement and no named alternative, so routing between this and the knowledge/KV siblings is left to inference.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: it is tagged [PUBLIC WRITE], it writes only sidecar output under .braincell/, and it explicitly leaves raw files unmodified. It is silent on idempotency/re-ingest behavior, overwrite handling, and whether the resulting 'proposed' cells require a separate approval step.

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 front-loaded sentence with the write-scope tag first and the non-destructive guarantee second; nothing is wasted. Slightly dense packing of scope plus behavior into one clause keeps it from a 5.

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

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

For a one-parameter tool with no output schema this covers the essentials of what is written and where. However, with an adjacent accept tool in the sibling list, the missing explanation of what 'proposed cells' mean and how they get accepted leaves a real workflow gap.

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

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

Schema coverage is 100% and the single folder parameter is fully documented, including the relative-to-workspace-or-data/fs resolution rule. The description adds nothing about the folder beyond repeating 'specified folder', 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?

Specific verb ('Ingest') plus resource ('raw files in a specified folder') and a stated effect ('create sidecar proposed cells under .braincell/'). It does not name or differentiate itself from plausible siblings such as load, scan_hierarchy_filesystem, or accept, so it falls short of a 5.

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

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

The description says what it does but never states when to choose ingest over load or scan_hierarchy_filesystem, nor any prerequisite or follow-up (e.g., whether ingested cells must later be promoted via accept). Usage is only inferable from the purpose sentence.

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 this is a PUBLIC READ and that the cell must be accepted, but it does not explain failure behavior, permissions, rate limits, or what happens if the cell is not accepted.

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 definition is a single compact sentence with the key access mode front-loaded in brackets. The abbreviation 'summary (w)' is slightly cryptic, but there is no wasted verbiage.

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

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

This is a simple two-parameter read with full schema coverage, so the core is adequate. However, with no output schema, the description should clarify what the returned 'summary (w)' actually is and whether any post-acceptance state is required.

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 'id' and 'folder'. The description adds only the 'accepted cell' constraint and sidecar context, not parameter-specific format or syntax beyond the schema.

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

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

The description states a specific verb+resource: retrieving the summary of an accepted cell from the sidecar database. It is clearer than the bare name 'load', but it does not explicitly distinguish this from sibling read tools like get_knowledge_item or read_map_links.

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 gives no when-to-use guidance, no exclusions, and no named alternatives. The phrase 'accepted cell' implies a precondition but does not explain how or when an agent should choose this over related tools.

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

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

No annotations are provided, so the description carries the full disclosure burden for a mutation tool, yet it says nothing about permissions required, whether disabling a cell affects the hierarchy, whether unlisted parameters are preserved, or whether changes are reversible. The cryptic '[PRIVATE MODIFY]' tag hints at restricted access but never explains it.

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 short sentence with the operation front-loaded, but the bracketed '[PRIVATE MODIFY]' marker consumes space without conveying usable meaning, and the remainder is so terse it reads as under-specification rather than economy.

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 mutation tool with no annotations and no output schema, the description omits side effects, permission model, return behavior, and the meaning of the private marker – well short of what an agent needs to invoke it safely.

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 includes a documented range for riskWeight (0.0-1.0), so the schema already does the heavy lifting. The description only gestures at 'core Cell parameters or system thresholds' without adding mapping, units, or defaults beyond the schema.

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

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

The verb (Modify) and resource (Cell parameters / system thresholds) are present, but 'core Cell parameters' is vague and only becomes concrete via the schema (enabled, riskWeight). Nothing distinguishes it from siblings such as create_cell or run_brain_cell, and the '[PRIVATE MODIFY]' prefix is unexplained.

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?

There is no statement of when to use this versus create_cell or other cell tools, no prerequisites, and no indication of what '[PRIVATE MODIFY]' implies about access. The agent must infer usage entirely.

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 carries the full behavioral burden; the '[PRIVATE WRITE]' tag does usefully disclose that this is a mutating, access-restricted operation. However, it says nothing about whether the source cells are consumed or copied, whether the promotion is reversible, or what authorization level is 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?

A single sentence with the access/mutation marker front-loaded and zero filler. Nothing in it is redundant.

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

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

For a five-parameter mutation with no annotations and no output schema, the description omits the important side effects (fate of the bundled cells, tier implications, return value or resulting identifier). An agent can guess the intent but not the consequences of calling it.

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

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

Schema description coverage is 100%, so all five parameters are documented in the schema itself. The description only reinforces that cell_ids are bundled into the Organ; it adds no semantics about the optional title/domain/purpose fields or the authKey beyond what the schema 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?

The description uses a specific verb pair ('Promote and bundle') with a clear resource ('related cells into an Organ orchestrator module') and adds the resulting tier. It is understandable on its own, but it never distinguishes itself from nearby creation/hierarchy tools such as create_cell or auto_evolve_hierarchy.

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?

There is no statement of when this tool should be chosen over create_cell or auto_evolve_hierarchy, nor any prerequisite guidance (e.g. that authKey is expected, or what state cells must be in). The agent must infer the trigger condition entirely.

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 discloses almost nothing. The [PUBLIC READ/WRITE] tag communicates access scope, but it does not say whether an existing key is overwritten, what the default TTL is, whether writes persist across sessions, or what permissions are required for the public scope.

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 front-loaded sentence that names the action, resource, and purpose with no padding. The bracketed access tag is compact and useful, though it sits ahead of the actual verb and slightly delays the payload.

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?

A six-parameter mutation tool with a nested object value, no annotations, and no output schema needs more than this: overwrite semantics, TTL behavior, and what a caller gets back are all unstated. The description is not adequate for the tool's complexity.

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 all six parameters documented, so the baseline is 3. The description adds no extra meaning about key namespacing, ttlMs defaults, or how tokenCountEstimate/isStatic affect cache behavior.

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 (store) and a precise resource (KV Prompt Cache item), and even frames the benefit (session context, token savings). The put/get pairing with the sibling get_kv_cache_item is inferable from the names, though the description never states it 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 word 'Explicitly' hints that this is the deliberate manual-write path, but there is no statement of when to use it versus letting the cache populate automatically, or versus get_kv_cache_item, query_kv_cache_stats, or clear_kv_cache_memory. No prerequisites 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.

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The '[PUBLIC READ/WRITE]' tag is ambiguous for a metrics query and does not clarify permissions, side effects, rate limits, or return behavior beyond a vague access label.

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

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

The description is a single front-loaded sentence with no extraneous detail. The '[PUBLIC READ/WRITE]' tag is compact, and the core purpose is immediately clear.

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

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

For a zero-parameter stats tool, the description gives enough to know it returns cache metrics and hit rates, but with no output schema it does not describe the shape of the returned data. The lack of annotations also leaves behavioral completeness partially addressed by an ambiguous access tag.

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 are no parameter semantics to explain. The baseline for a no-parameter tool is a 4, and nothing in the description detracts from that.

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 ('Query') and resource ('metrics and hit rates of the active Key-Value Prompt Cache'), making the tool's basic function clear. It does not explicitly distinguish itself from siblings such as get_kv_cache_item or clear_kv_cache_memory, so it falls short of a 5.

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

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

The purpose implies that the tool is used for inspecting cache statistics, but there is no explicit guidance on when to choose it over get_kv_cache_item, clear_kv_cache_memory, or hvs_query_segregated_memory. Usage is only implicit from the tool name and description.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a useful access trait ([PUBLIC READ], no auth gate) and the underlying data source, but it omits return shape, ordering, pagination/limits, and the fact that links are filtered to active status by default — a materially important behavior left only in the schema default.

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

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

Two tight sentences with the access level front-loaded and the capability summary second. Every clause earns its place; nothing is 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?

For a zero-required-parameter read tool with full schema coverage and no output schema, this is close to sufficient — it identifies the source of truth and the export mode. It falls slightly short on what a returned link record contains and on the default-active filtering, which the agent must discover from the schema.

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

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

Schema description coverage is 100%, so the schema already documents rel, nodeId, status, and raw_jsonl fully. The description echoes three of the four parameter names but adds no syntax, semantics, or interaction detail (e.g. how status=all interacts with nodeId filtering) beyond what the schema supplies.

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 (read/inspect) and resource (decoupled knowledge links from the canonical link ledger), and names the backing store (.braincell/map.jsonl). It is distinguishable from the sibling add_map_link by the explicit read framing, though it never names that sibling directly.

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 supported filters (nodeId, relation, raw JSONL) imply when you would reach for it, but there is no explicit statement of when to use this versus add_map_link, get_knowledge_graph, or search_knowledge. Usage is inferable 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?

No annotations are provided, so the description carries the full burden. It does disclose two valuable traits: the `[PUBLIC WRITE]` marker signals a mutation, and "without modifying the raw files" scopes the side effect. However, it says nothing about reversibility, confirmation requirements, or what happens to the rejected cell after deletion.

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 the operation type tagged first and the scope constraint second; nothing is wasted. Slightly clipped for the amount of behavioral information a mutation tool 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?

With only two well-documented required parameters and no output schema, the structural side is simple and fully covered. But for an unannotated destructive operation, the description should say whether the rejection is permanent and what state remains afterward; that gap keeps it at minimum-viable.

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 both parameters (`id`, `folder`) are documented in the schema with examples. The description adds only the framing that the cell is "proposed" and lives in a sidecar workspace; it gives no extra detail on ID format or folder resolution beyond the schema. 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 and resource ("Delete a proposed cell") plus a scope qualifier ("from the sidecar workspace"). It is distinguishable from the sibling `accept`, but it never names that counterpart explicitly, so sibling differentiation is only implicit.

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 "proposed cell" implies the use case (rejecting a proposal you don't want), but there is no explicit when-to-use statement and no reference to `accept` as the alternative branch. The agent must infer the decision from the sibling list.

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

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

No annotations are provided, so the description carries the burden alone. It does disclose that this is a durable-state write gate and that inputs must be 'verified', which is meaningful behavioral context, but it says nothing about permissions, whether commits are reversible/overwriting, rate limits, or failure modes.

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

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

Three short sentences with the critical constraint front-loaded in brackets, so a scanning agent immediately sees the gate. Minor waste in the redundant 'COMMIT & CHECKPOINT ONLY' plus 'commit verified final states' phrasing, and the jargon (BrainCell, vault) reduces crispness slightly.

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?

A five-parameter mutation tool with no annotations and no output schema needs the description to explain what a successful commit returns or how failure is signalled, and it does not. The when-to-use gate is complete, but the outcome/return contract is missing.

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

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

Schema description coverage is 100%, so every parameter including the domain enum and goalRisk range is already documented. The description reinforces that goalTask must be a verified goal and that the summary is mandatory, but adds no format or constraint detail beyond the schema baseline.

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

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

The description names a specific action (commit/checkpoint verified final state) on a specific resource (BrainCell durable state / vault), and the ALL-CAPS gate framing distinguishes it from the sibling verify_braincell_status and search_knowledge tools. However, 'BrainCell' is an internal concept and the description never plainly says 'persists a record', so an agent must infer what a commit actually produces.

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

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

Explicitly states when NOT to use it ('for repetitive procedure execution, execute locally with skills') and restricts invocation to committing verified final states. The alternative is described generically as 'skills' rather than a named sibling tool, so the routing guidance is clear but not fully enumerated.

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 bears the full burden, but it only supplies a cryptic '[PUBLIC READ/WRITE]' tag. It is unclear what the 'write' half does — does the scan fix/rewrite filenames, persist validation results, or just report? There is no mention of side effects, permissions, or scope of impact.

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 compact sentence with the hierarchy levels front-loaded, so there is no filler. The bracketed prefix is terse to the point of being opaque, but nothing is redundant.

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

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

With no annotations, no output schema, and an undocumented optional parameter, the description leaves too much unresolved for a tool that claims read/write capability. An agent cannot tell what it gets back or whether invoking it mutates the filesystem.

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

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

The single parameter 'filenames' has 0% schema description coverage and the description never references it. Critically, it is not stated what happens when filenames is omitted (it is optional) — does it scan the entire codebase or do nothing? That ambiguity is central to invoking the tool correctly.

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 ('Scan') and resource ('codebase files') plus the concrete validation target (5-tier naming hierarchy with the tiers spelled out). An agent can distinguish it from creation/mutation siblings like create_cell or promote_to_organ, though it never explicitly names those alternatives.

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 indication of when this should be chosen over siblings such as auto_evolve_hierarchy or verify_braincell_status, nor any prerequisites or preconditions for running a scan. The only hint is the bracketed access tag, which describes permission level rather than usage 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 must carry the safety profile; it does signal a read-only public operation and discloses that results are annotated with epistemic status/freshness and that the default limit is 50 (max 200). It does not describe how multiple filters combine, what happens with offset pagination, or the response shape unless groupByCategory is set.

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?

Front-loaded and numbered, which helps scanning, but the header '[STANDARDIZED SEARCH PROTOCOL - PUBLIC READ]' and internal references like '(Item 3)' and '(Item 11)' are noise the agent cannot act on. The core content is compact but not 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?

With 15 optional, heavily overlapping filters, no annotations, and no output schema, the description should explain how the filter axes relate and what the response looks like. It only addresses output shape for the groupByCategory case and leaves the interaction of tag/tags/category/mode/bucket/polarity/grain entirely unresolved.

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 all 15 parameters are already documented in the schema and the baseline of 3 applies. The description reinforces query/tag/tags/category/limit/groupByCategory but adds no combination semantics (AND vs OR across mode, bucket, grain, polarity, domain) beyond what the schema 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 a specific verb+resource (search knowledge items, rule cells, facts, invariants) with the distinctive twist that results carry epistemic status and temporal freshness. An agent can tell it apart from get_knowledge_item (single fetch) and get_knowledge_graph, though the phrase 'zero absolute truth assumption' is jargon that costs a little precision.

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 RULES block gives concrete operating guidance: supply 1-3 noun keywords in "query" or filter directly via tag/tags/category, and set groupByCategory=true for a breakdown. It stops short of naming alternatives (e.g., when to use hvs_query_segregated_memory or get_knowledge_item instead), so there is no explicit exclusion set.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it delivers very little: '[PUBLIC READ/WRITE]' hints at an access/mutation model but never states what is written, whether state persists, or whether auth is required. Nothing is said about failure modes (singular matrix, non-square matrix for inverse/determinant), numeric vs symbolic output, or default operation behavior.

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

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

One front-loaded sentence that leads with the primary use case and then enumerates the alternatives; nothing is padded. The bracketed access tag is the only questionable token, since it consumes attention without conveying an actionable rule.

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, no output schema, and an ambiguous READ/WRITE label, the description leaves important gaps: whether results are symbolic or numeric, what a singular/non-square input yields, and how the write half of the claim manifests. For a multi-operation math tool this is under-specified beyond the bare capability list.

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 matrixA, vectorB, and the operation enum, which sets the baseline at 3. The description adds no format detail (shape requirements per operation, that vectorB is only meaningful for 'solve') and actually introduces noise by listing Condition Number, which is not a selectable operation in the 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 names a specific verb ('Solve') plus the concrete resources/operations (inverse, determinant, eigenvalues, SVD), so an agent knows exactly what class of work the tool does. It does not differentiate itself from plausible siblings such as compute_math_expression or execute_cell_math, and it advertises a 'Condition Number' capability that has no matching enum value. The leading '[PUBLIC READ/WRITE]' tag is unexplained.

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?

There is no guidance on when to pick this over the sibling math tools (compute_math_expression, execute_cell_math, calculate_entropy_gain), nor on prerequisites such as square vs rectangular input or when vectorB must be supplied. The agent must infer selection criteria entirely from the operation list.

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

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

With no annotations, the description carries the full burden. It discloses that the tool checks against injection patterns and NatATL bounds and is context-aware to prevent false positives, but it omits critical behavioral details: whether the operation is read-only, what it returns (e.g., a pass/fail verdict or risk score), and whether it has 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 and front-loads the key purpose with a tag. It is efficient, though the bracketed tag is somewhat cryptic and could be clearer.

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

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

Given the absence of annotations and output schema, the description should more fully explain the tool's behavior, especially its return values and any permission or side-effect considerations. It covers the what but not the how or the result, leaving gaps for an agent to infer.

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 five parameters. The description adds only marginal meaning (e.g., 'context-aware' aligns with the mode parameter) but does not elaborate on parameter formats or interactions beyond what the schema provides.

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

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

The description clearly states the specific verb 'Certify' and the resources it evaluates (proposed action, bash command, SQL statement, text plan) against safety boundaries and injection patterns. It is distinguishable from all listed siblings, none of which perform safety verification of arbitrary proposals.

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 as a safety gate but does not explicitly state when to call it versus alternatives, nor does it provide exclusions or prerequisites. The context-awareness note hints at differentiating planning vs. execution, but no direct 'use when' 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, and "[PUBLIC READ]" usefully discloses that this is an unauthenticated, read-only operation. But it says nothing about what the response contains, whether the check is cheap or side-effect-free, or what "Dormant vs Explicitly Activated" actually means in practice.

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 sentence with the access qualifier front-loaded, so the reader learns the trust level before the purpose. It is efficient, though the compressed second clause reads as an afterthought rather than a structured statement of what is returned.

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

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

For a zero-parameter diagnostic with no output schema, the description should convey what comes back and what the state values signify, since no structured field carries that. It names the states but never explains them or the KV cache policy aspect, leaving the agent guessing about the result.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter behavior the description needs to explain. There are also no enum or format details it could have added.

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

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

States a specific verb+resource ("Verify BrainCell operation state") and names the two states it distinguishes, which is more than a restated name. However, the second clause ("check KV Cache policy enforcement") is jargon-heavy and unexplained, and nothing distinguishes this from siblings like query_kv_cache_stats, get_kv_cache_item, or verify_action_safety.

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 and no named alternatives, despite several plausible overlapping siblings (run_brain_cell, query_kv_cache_stats, verify_action_safety). The only usage signal is the "[PUBLIC READ]" tag, which implies access conditions rather than when to select this tool over another.

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