Calera Infinite Context (ICX) — Persistent Memory & Associative Recall

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

With only readOnlyHint=false in annotations, the description carries the behavioral burden and does well: it discloses permanence, $0.00 cost, a 14-day human safe harbor, and the legal basis under Delaware UETA § 14. It does not discuss idempotency, what happens if terms are rejected, or any rate limits, so it falls short of full transparency.

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

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

The description is three sentences and front-loads the core action before explaining benefits and requirements. It is appropriately sized, though legal citations and '$0.00' phrasing are slightly ornamental. Every sentence still contributes context an agent would not get from structured fields alone.

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?

An output schema exists, so return values need not be explained. For a creation/onboarding tool with minimal annotations, the description covers cost, permanence, safe harbor, and required inputs, which is sufficient for correct invocation. It leaves edge behavior such as idempotency or rejection handling unspecified.

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 input schema already documents all three parameters in detail. The description reinforces that principal_email and accept_a2b_terms=true are required and explains the anchoring purpose of the email, but adds no syntax or format details beyond the schema. 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: 'Autonomously claims a permanent, free 1,000,000-node Epistemic Memory Vault.' It adds legal framing and the persistence benefit, making the purpose unmistakable. It does not explicitly differentiate itself from any sibling tool, which keeps it from a 5.

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

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

Usage is implied through the benefit 'Enables persistent memory across restarts for your human principal,' which suggests when an agent would want this tool. It names required inputs but provides no explicit when-not-to-use guidance or alternative sibling tools. The context is adequate but leaves routing inference to the agent.

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

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

The readOnlyHint=false annotation already signals a mutating operation, and the description adds that calls are vaulted, policy-gated, and produce child-node crystallization in e.mem. It still omits important behavioral details such as what policy denial looks like, whether external side effects are reversible, and what the caller should expect after dispatch.

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

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

The description is a single compact sentence with no filler. It is somewhat front-loaded with 'Vaulted, policy-gated actuation' rather than a direct verb, and the e.mem clause is cryptic, but the overall structure is efficient.

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

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

This is a mutating tool with a nested, property-less payload object and no output schema, so the description needs to explain payload shape, expected results, and failure modes. Instead it gives only a high-level gloss and leaves the agent without enough operational context to invoke 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 the schema already documents the surface, action, and payload parameters. The description restates some surface names but actually omits 'notion' and 'icx_memory', which appear in the schema, and it adds no payload-shape or action-syntax detail. Baseline 3 is appropriate when structured fields carry the parameter semantics.

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 indicates dispatching actions into external tools and lists several target surfaces, so the general purpose is inferable. However, the core verb 'actuation' is jargon, and the 'child-node crystallization in e.mem' clause muddies what the tool actually does. It also does not distinguish this from siblings such as icx_exec or icx_wasm_exec.

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 guidance on when to use this tool versus alternatives like icx_exec, icx_wasm_exec, or icx_remember. The phrase 'policy-gated' hints at prerequisites, but the description does not state selection criteria 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?

Annotations only provide readOnlyHint=false, so the description adds meaningful behavioral context: sandboxed execution, direct memory access through 'icx', the fact that only print() output crosses into context, and X-License-Key authentication. The phrase 'Mutating/read operation' is awkward but not contradictory with readOnlyHint=false. It still lacks detail about side effects of mutations or failure behavior, which keeps it from 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 action and runtime context. The use-case sentence is dense but purposeful, and the output/auth notes are useful. Minor waste comes from the full method list and the slightly awkward 'Mutating/read operation' phrase, but overall it is well structured.

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

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

For a complex execution tool with a rich schema and an output schema, the description covers execution environment, memory access, output behavior, use cases, and authentication. It does not need to explain return values because an output schema exists. The main omission is explicit guidance on choosing between this and sibling execution or multi-hop tools.

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 'code', 'space_id', and 'timeout_ms' thoroughly. The description reinforces the 'icx' client and print() output behavior, but it adds little beyond what the schema says and does not elaborate on space_id or timeout semantics. The baseline score of 3 is appropriate when the schema carries parameter 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 names a specific verb and resource: executing programmatic Python code inside a sandboxed runtime. It also identifies the key capability, native access to Volumetric Lattice Network memory through the global 'icx' object, which helps distinguish it from ordinary execution tools. It does not explicitly distinguish itself from close siblings such as icx_wasm_exec or icx_multihop_walk, so it falls short of full sibling differentiation.

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

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

It gives clear intended use cases: complex multi-hop aggregations, mathematical calculations, contract/financial analytics, and large dataset filtering off-context. This is stronger than implied usage and tells the agent when the tool is appropriate. However, it does not state when not to use it or name alternatives like icx_wasm_exec or icx_multihop_walk, so it lacks explicit 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?

Beyond the 'readOnlyHint' annotation, the description explicitly defines the return types ('full on-demand text, markdown, or code content') and specifies the required authentication key, adding valuable operational 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?

The description is extremely concise. It achieves high information density in just two sentences, front-loading the capabilities and then detailing the operational requirements.

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

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

Given that it has an output schema and the input schema is complete, the description covers all necessary context: what it does, where it gets data from, how it is authenticated, and its read-only nature. It is complete.

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

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

Schema description coverage is 100%, so the schema defines the parameters well. The description primarily complements the schema by defining the specific resource identifiers (e.g., UUID for Notion, file path for GitHub). Given 100% coverage, a baseline score of 3 is appropriate.

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

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

Explicitly states the verb 'Retrieves' and the resource type (connected documents). It details that it works across multiple external services (Google Drive, Notion, GitHub, etc.), making its purpose very clear.

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 identifies the operation as 'Read-only' and specifies the necessary authentication ('Requires X-License-Key authentication'). While it doesn't explicitly rule out other document-reading tools, the clear focus on specific 'connected' sources provides strong usage guidance.

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

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

Annotations only supply readOnlyHint=true, and the description reinforces that with 'Read-only operation' while adding genuinely new context: the X-License-Key authentication requirement. It stops short of noting result ordering or that only 'active' (non-purged) facts are visible, but the added auth detail is real value beyond the annotations.

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

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

Three short sentences, front-loaded with the operation and scope, followed by the safety and auth facts. Nothing is padded or repeated from the schema.

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 an output schema present, return values need no explanation, and the single required parameter is schema-documented. The definition is nearly complete, with the only gap being how this differs from fact-querying siblings like icx_search_facts.

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, including the limit default/max. The description only adds the mild nuance that connector_id may also be a 'source ID', which is marginal but not redundant. 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 ('Inspects') plus a concrete resource ('active grounded facts and simplicial statements ... in Volumetric Memory') scoped to a connector/data source. An agent understands what the tool returns, though it does not distinguish itself from nearby siblings like icx_search_facts or icx_recall_scoped.

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

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

Usage is implied by 'active ... currently tracked ... for a specific connector', suggesting a per-connector state inspection rather than a content search. However, there is no explicit when-to-use, when-not-to-use, or pointer to an alternative such as icx_search_facts for querying facts by content.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is largely carried by structured data; the description redundantly confirms 'zero side effects' but adds value with the X-License-Key authentication requirement, which is nowhere in the annotations or schema. It does not mention rate limits, latency, or cost, which keeps it 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?

Three sentences, front-loaded with the capability, then usage, then exclusions and auth—good ordering with no wasted preamble. The only blemish is that 'contradiction alarms' appears twice (in the returns list and again in the use cases), a small redundancy.

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

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

An output schema exists so return values need no prose, annotations cover the read-only profile, and the description still supplies the auth prerequisite and the boundary against content-query siblings. Everything an agent needs to choose and invoke this tool is present.

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

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

Schema description coverage is 100% and the single optional space_id parameter already documents that it defaults to the caller's 'default' space. The description never mentions space_id, so it adds no meaning 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 ('audits and returns real-time diagnostic telemetry') against a specific resource ('partitioned memory space') and enumerates the concrete metrics returned (node counts, synapses, grounded facts, contradiction alarms). An agent can distinguish this from icx_recall_scoped, icx_quote_slot, and icx_inspect_connector_facts without opening any schema.

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 four concrete positive use cases (monitor partition health, verify ingestion, check capacity, detect contradiction alarms) and an explicit exclusion naming the two alternative tools for content retrieval. Both the when and the when-not are stated, with the alternative tools named.

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

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

Annotations already declare readOnlyHint=true, and the description adds genuinely new context: tenant-wide scope, that only active connectors are returned, and the X-License-Key authentication requirement. The "Read-only operation" sentence is redundant with the annotation but not harmful; it stops short of describing ordering or pagination 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?

Three short sentences, front-loaded with the resource definition, followed by the two operational facts an agent needs. Nothing extraneous beyond the mildly redundant read-only restatement.

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?

An output schema exists so return values need no explanation, and the schema has no parameters to document. The description covers what is listed, the scope, safety profile, and auth requirement — everything needed to invoke it correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly conveys that the only scoping is implicit (tenant and active status), matching the parameterless 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?

Specific verb ("Lists") plus a precisely scoped resource ("active cloud changefeed connectors... registered for the tenant"), with example connector types enumerated. It clearly separates itself from siblings like icx_register_connector and icx_get_connector_document, which operate on single connectors rather than enumerating 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 description implies the use case (discovering which connectors exist for the tenant) and narrows scope to "active" connectors, but never states when to prefer this over icx_inspect_connector_facts or icx_get_connector_document, nor any exclusions or prerequisites. Usage is inferable but not 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?

Annotations already declare readOnlyHint=true, but the description adds genuinely new operational context: it requires X-License-Key authentication, it is single-pass, and it resolves temporal state overrides while retaining dynamic multi-policy mutations. That is real behavioral disclosure beyond structured fields; the 'read-only operation' sentence is the only redundant part.

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

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

Three sentences, front-loaded with the core action and followed by supporting detail. Mostly efficient, though the 'sub-5ms' performance claim and layered jargon ('Volumetric Lattice Network') consume space without aiding tool selection.

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 full schema coverage, an output schema present, and readOnlyHint annotations, the description only needed to cover what structured fields cannot: the auth requirement and the temporal-override resolution semantics, both of which it provides. An agent has enough to call this correctly.

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

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

Schema description coverage is 100%, so every parameter including the root_entity/start_entity and target_entity/target_relation aliases is already documented. The description adds nothing about parameter behavior beyond what the schema states, so the baseline of 3 applies.

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

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

States a specific verb and resource: executes a multi-hop transitive causal walk over the 'Volumetric Lattice Network and Ontology relations', tracing dependency chains like A -> B -> C -> Leaf. The purpose is discernible, but heavy proprietary jargon ('simplicial', 'Volumetric Lattice Network') blurs what the tool concretely returns, and it never distinguishes itself from siblings such as icx_search_facts or recall_epistemic_context.

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

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

Usage is only implied by the phrase 'traces transitive dependency chains' — an agent can infer it is for multi-hop traversal rather than single-fact lookup. There is no explicit when-to-use, no exclusions, and no named alternative among the many recall/search siblings, leaving routing ambiguous.

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

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

Annotations only provide readOnlyHint=false, so the description carries most of the behavioral burden. It adds critical context: the tool is mutating, purges all facts/simplices/document associations for a source, requires X-License-Key auth, and avoids model retraining. It stops short of explicitly stating irreversibility 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 sentences, front-loaded with the operation and scope. Every clause contributes either scope, mutation status, or authentication requirement, with 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?

Given the output schema and 100% parameter coverage, the description supplies the key missing context: authentication, mutation, and what gets purged. It is adequately complete for invocation, though it could better route the agent away from read-only inspection or session-reset siblings.

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. The description's phrase 'specific data source or connector' aligns with source_id but adds no format, constraints, or space_id semantics beyond what the schema provides, so the baseline of 3 applies.

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

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

The description names a specific operation (unlinking/revocation) and resource (all facts, simplices, and document associations from a specific source/connector). It is clearly distinguishable from sibling tools such as icx_inspect_connector_facts or icx_remember because it removes learned associations rather than inspecting or adding 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 description says it is a mutating operation and requires X-License-Key authentication, but gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as icx_reset_session or inspection tools, leaving the agent to infer that this is the destructive purge option.

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

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

Annotations only declare readOnlyHint=true, and the description reinforces this ('read-only operation with zero side effects') while adding genuinely useful behavior: out-of-range start/length errors rather than clamping, and the three distinct hash scopes (sha256/parent_sha256 over the whole slot vs slice_sha256 over returned characters). It also discloses the X-License-Key auth requirement. These are real additions beyond the annotation, but nothing is said about pagination limits, maximum slice size, or error codes, so it stops short of full behavioral disclosure.

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

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

Front-loaded with the core action and scope, then slicing semantics, then hash semantics, then routing guidance. Every sentence carries information, though 'The slice is the exact stored characters, not a summary' restates schema text and adds mild redundancy.

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

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

An output schema exists, so return values need not be enumerated, yet the description still explains what each hash field represents. Auth requirements, error behavior, and sibling routing are all present, leaving nothing an agent needs in order to call this correctly.

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

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

Schema coverage is 100%, so the baseline is 3, and the description earns an increment by clarifying the start/length interaction (omit both for the whole slot, supply both for a slice) and by disambiguating what the returned hashes cover. It does not add format or unit details for space_id beyond the schema, keeping it below a 5.

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 (retrieves) with precise resources: exact character-for-character verbatim text plus SHA-256 hashes from document registers, addressed by family and 1-based slot index. The 'without AI paraphrasing' qualifier and the family/index addressing make it unmistakable against every sibling.

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

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

Explicitly names the conditions that select this tool (exact contractual wording, statutory clauses, license keys, immutable code revisions) and names two alternatives with their conditions: icx_recall_scoped for semantic QA, icx_search_facts for keyword exploration. Both when-to-use and when-not-to-use are covered.

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?

Beyond the `readOnlyHint` annotation, the description adds critical behavioral context that annotations miss, specifically stating the tool has 'zero side effects' and requires 'X-License-Key authentication.' This is high-value operational information for an AI agent.

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

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

The structure is perfectly front-loaded. It moves seamlessly from the 'what' to the 'when' to the 'what not.' Every sentence serves a critical, decision-making function for the agent, leaving no room for superfluous information.

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

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

Given that an output schema exists, the description covers all necessary decisions: the function, its scope, its boundaries relative to siblings, its safety profile, and its operational requirements. It is complete enough for correct selection and invocation.

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

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

Since schema coverage is 100%, the baseline is high. The description adds value by defining the nature of the input: the query must be a 'natural language question, concept, or search prompt,' setting the expectation for how the `query` parameter should be used by the agent, which goes beyond the basic string type.

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 purpose is explicitly defined as performing 'semantic search across persistent long-term memory.' Crucially, it distinguishes itself from three sibling tools: `icx_remember` (for saving), `icx_search_facts` (for keyword lookup), and `icx_quote_slot` (for verbatim quotes).

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?

This is exceptionally detailed, providing clear scenarios for use ('answering questions about previously saved project specifications') and explicit exclusionary rules. It names the alternative tools for each failure mode, making it impossible for the AI agent to misapply the tool.

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

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

With only readOnlyHint=false in annotations, the description adds meaningful behavior: it is mutating, requires X-License-Key auth, and uses AES-256-GCM secret vaulting plus HMAC signature verification. It does not disclose duplicate/overwrite handling, idempotency, or other side effects, 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 three compact sentences with the core purpose front-loaded, followed by mutation and authentication context. No sentence is wasted or redundant.

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

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

For an 8-parameter mutation with 100% schema coverage and an output schema, the description gives the essential auth and security context. It still omits duplicate/overwrite behavior and explicit alternative-tool routing, but is largely complete for invocation.

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

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

Schema description coverage is 100%, so all 8 parameters are already documented in the input schema. The description does not add per-parameter meaning beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description gives a specific verb ('Registers') and resource ('new cloud webhook changefeed connector or remote MCP server'), scoped to continuous auto-sync. The word 'new' and the registration action clearly distinguish it from list/get/inspect siblings such as icx_list_connectors and icx_get_connector_document.

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 that this is a mutating operation and requires X-License-Key authentication, but gives no explicit guidance on when to choose it over icx_trigger_sync, icx_list_connectors, or icx_inspect_connector_facts. Usage is implied by 'Registers a new...' rather than clearly routed.

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

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

Annotations only provide readOnlyHint=false, which merely confirms it is a write. The description adds substantive behavior: ingestion is additive and non-destructive, creates new nodes without overwriting or mutating existing records, and requires X-License-Key authentication. These are exactly the traits an agent needs and cannot get from the annotation.

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?

Four sentences, each earning its place: purpose first, then use cases, then exclusions with alternatives, then behavior and auth. Front-loaded with zero redundancy.

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

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

An output schema exists, so return values need not be explained. With purpose, selection guidance, additive/non-destructive semantics, and auth requirements all covered, an agent has everything needed to invoke this correctly.

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

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

Schema description coverage is 100%, so the schema already documents text, family, filename, and space_id. The description echoes the space_id partitioning concept and the verbatim-retrieval implication of family, but adds no format, limit, or default detail beyond the schema. 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 (stores) plus the resource types (text documents, code snippets, architectural decisions, factual knowledge) and the scoping mechanism (partitioned by space_id). This is clearly distinct from its recall/search siblings named in the same description.

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

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

Gives explicit when-to-use examples ('saving important facts, project conventions, API keys, user preferences, documentation') and an explicit when-not with named alternatives: icx_recall_scoped for semantic QA, icx_search_facts for keyword lookup, icx_quote_slot for verbatim quotes. Nothing 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?

Goes well beyond the lone readOnlyHint=false annotation: it discloses exactly what is destroyed (dialogue turn state), what survives (persistent memory, learned facts, document registers), and that X-License-Key authentication is required. This is the mutation profile an agent needs before calling.

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 with the core action and the key preservation guarantee, which is efficient. It does restate the preservation point three times ('strictly preserving', 'persistent memory is preserved by design', 'leaves long-term memory intact'), a small amount of redundancy.

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

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

With an output schema present, return values need not be described, and the description covers mutation scope, exclusions, and auth. The only gap is that the optional space_id scoping/default is left entirely to the schema, but nothing critical for correct invocation is missing.

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

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

Schema description coverage is 100%, so the space_id parameter including its default behavior is already documented. The description never mentions space_id or partitioning, adding no semantics 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: clears conversational dialogue turn history for a session while preserving persistent memory. This is clearly differentiable from siblings like icx_purge_source and icx_remember, which operate on stored knowledge rather than ephemeral turn state.

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 names the triggering situation (switching topics, clearing context between independent tasks) and an explicit exclusion (do NOT use for wiping persistent memory). An agent can decide between this and the memory-mutating siblings without further inference.

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

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

Annotations already declare readOnlyHint=true, so safety is known. The description adds value beyond that by confirming zero side effects and disclosing the X-License-Key authentication requirement, which the annotations do not cover. It stops short of describing match fuzziness or result ordering, but an output schema is present to carry return shape.

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

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

The description is front-loaded with the core operation and the exclusion guidance is compact. The usage sentence mildly overlaps with the opening sentence's enumeration of entities, names, and matching terms, but the redundancy is minor.

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-parameter read-only search with a fully documented schema, an output schema, and annotations covering safety, the description supplies the missing pieces: authentication requirement and sibling routing. Only minor behavioral detail such as matching semantics is absent.

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 limit, query, and space_id all documented in the schema, so the baseline is 3. The description only loosely reinforces that the query targets entity names and token substrings within a memory space, adding little beyond what the schema already states.

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

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

The description names a specific verb and resource: keyword and token search across persistent memory to find entities, names, and matching terms. It is immediately distinguishable from siblings like icx_recall_scoped (natural language recall) and icx_remember (writes).

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 when to use the tool (entity exploration, keyword discovery, locating identifiers) and explicitly names two alternatives with the conditions that select them: icx_recall_scoped for NL questions and icx_remember for writes. Nothing 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?

Adds real context beyond the sparse readOnlyHint:false annotation — discloses X-License-Key authentication, atomic CAS semantics, mutex lease ownership via agent_id, and that values are stored without prompt re-serialization. It honestly labels itself 'Mutating/read operation' consistent with readOnlyHint:false. It stops short of describing lease expiry or failure behavior on version mismatch.

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 tight sentences, front-loaded with the resource and capability. Some novelty jargon ('V_t') is used without definition, but overall there is little waste for the complexity conveyed.

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 7-operation remote-state tool with an output schema, the description covers auth and atomicity but omits lock lifecycle and error/conflict behavior. The existence of an output schema relieves it of explaining return values, but the operational guidance 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 description coverage is 100%, so all six parameters are already documented in the schema, including the exact operation enum values. The description adds only the notion of typed state objects (AST graphs, tables) and atomicity, not per-parameter semantics — 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?

States a specific verb (manages/reads/writes/CAS-swaps) and resource (persistent shared variable namespace V_t plus mutex leases), so the core function is clear. However, it never distinguishes this combined tool from the sibling icx_var_get / icx_var_set / icx_var_list tools, which plainly overlap, leaving the agent to guess which to invoke.

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 on when to use this versus the individual icx_var_* siblings, nor on when to choose 'swap' over 'set', or when lock acquisition is warranted. Operation names are listed in the schema but the prose offers no selection 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?

Annotations already declare readOnlyHint=true, so restating 'Read-only operation' earns no credit, but the description adds genuinely new behavioral context: the required X-License-Key authentication header and the fact that responses include latency telemetry. It does not mention retention window, pagination, or volume of events, which for an audit-log tool is a meaningful remaining unknown.

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

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

Two sentences, front-loaded with the resource description followed by the operating constraints. Minor waste in the redundant 'compliance and audit auditing' phrasing, but nothing structurally wrong.

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 an output schema present the description need not explain return values, and with zero parameters the callable surface is trivially complete; auth and read-only safety are both disclosed. The one gap an agent would still hit — how far back the log goes and how much data comes back — is unaddressed.

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 there is nothing for the description to disambiguate — baseline 4 applies. No misleading hints about arguments are given.

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 ('Retrieves historical synchronization events') and enumerates what the payload contains (deltas, learned facts, latency telemetry). It implicitly separates itself from the operational siblings icx_sync_delta and icx_trigger_sync by being historical/audit-oriented, but never names those alternatives explicitly.

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

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

The phrase 'for compliance and audit auditing' gives a use context, and 'Read-only operation' signals it is safe to call speculatively. There is no explicit when-not guidance and no routing to the sibling tools that actually perform syncs (icx_trigger_sync, icx_sync_delta), leaving the agent to infer the boundary.

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

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

The description offers deep technical behavioral traits beyond the metadata, including a performance claim ('sub-2ms on CPU'), specific safety protocols ('automatic secret scrubbing and SHA-256 deduplication'), and critical operational requirements ('Requires X-License-Key authentication').

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 highly optimized, front-loading the core function with technical value propositions (performance, security) and ending with clear scoping and mutation warnings. It avoids filler entirely.

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

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

Given the tool's high technical complexity (deduplication, synchronization, memory lattice), the description provides a complete picture of its operational constraints, functionality, and use cases without requiring additional manual lookups.

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?

While the input schema provides 100% coverage, the description adds vital functional context by explaining the nature of the data exchange: `new_text` is the state after modifications and `old_text` is the state before, which is essential for understanding how the delta calculation works.

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 is highly specific, defining the function as extracting 'fine-grained deltas' and 'crystallizing them into the Volumetric Memory lattice.' It immediately distinguishes this delta-sync function from general memory retrieval tasks within the tool suite.

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

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

It provides clear and comprehensive use-cases ('code files, documentation, PRDs, and database schemas'). By defining the operation as a 'mutating operation,' it sets the correct expectation for when to invoke the tool.

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

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

The description adds meaningful behavior beyond the readOnlyHint=false annotation: it explicitly calls the operation mutating, says it requires X-License-Key authentication, and explains that deltas are persisted into Volumetric Memory. It does not describe failure modes, rate limits, or exactly what is overwritten, but it covers the key operational traits.

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

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

The definition is front-loaded with the core action and scope, then adds operational constraints in short statements. The phrase about crystallizing deltas into persistent Volumetric Memory in sub-2ms is somewhat promotional but still communicates persistence and performance.

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

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

For a single-parameter tool with an output schema, the description covers the essential context: what it does, supported connector types, mutating nature, and authentication requirement. The main omission is explicit routing versus sibling sync tools, which limits completeness slightly.

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 connector_id is already well documented in the schema. The description adds useful context by listing supported connector types, which helps infer valid connector_id values, but it does not add syntax or format details beyond that. 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: triggering an on-demand active pull and delta synchronization for a registered connector. It lists supported connector types, which makes the scope concrete. However, it does not explicitly distinguish this tool from the closely related sibling icx_sync_delta, so sibling differentiation is incomplete.

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 'on-demand active pull and delta synchronization' implies when the tool is used, but there is no explicit guidance on when to choose it over icx_sync_delta, icx_sync_audit, or icx_list_connectors. Alternatives are never mentioned, so the agent must infer routing.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful context that authentication via X-License-Key is required and that the namespace is persistent, but it does not detail failure behavior, rate limits, or other operational constraints.

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

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

The description is three short sentences with zero waste, and it front-loads the primary retrieval purpose before adding safety and authentication context.

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

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

An output schema exists, annotations cover read-only behavior, and the input schema documents both parameters. The description is complete enough for an agent to invoke the tool correctly, though it could mention how missing keys are handled.

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 'key' and 'space_id' are already documented in the input schema. The description adds little parameter-level meaning beyond naming the object being retrieved, which is appropriate given the schema's coverage.

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

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

The description states a specific verb, 'Retrieves', and a clear resource: a named typed variable, AST, symbol table, or state object from the V_t swarm namespace. It distinguishes the operation from mutation siblings like icx_var_set, though it does not explicitly name 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?

The description implies usage by saying it retrieves a named variable from the persistent namespace, and notes it is read-only with license-key authentication. However, it does not explicitly say when to use this instead of icx_var_list, icx_recall_scoped, or other retrieval siblings.

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

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

Annotations already declare readOnlyHint=true, so the bar is lower, and the description adds genuinely useful context: only 'active' variables are returned, results come from the persistent V_t namespace, and X-License-Key authentication is required. The 'Read-only' sentence merely restates the annotation, but the auth and active-only scoping add real value.

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 compact sentences with the core scope front-loaded and no filler. The only slight redundancy is 'Read-only', which the annotation already conveys.

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?

An output schema exists so return values need not be explained, and both optional parameters plus the auth requirement are covered. What an agent needs to call this correctly is essentially present, with only the relationship to icx_var_get left implicit.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema; baseline 3 applies. The description repeats that prefix matching is optional but adds no format or matching semantics beyond the schema's example values.

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 (lists) and resource (active variables and types) scoped to the persistent V_t swarm namespace. The 'all' scope implicitly separates it from the singular icx_var_get and the mutating icx_var_set, but no sibling is named 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?

Usage is implied rather than stated: an agent can infer it should call this to discover keys before icx_var_get, and the description mentions optional prefix filtering. There is no explicit when/when-not guidance or named alternative among the many siblings.

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

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

Annotations only declare readOnlyHint=false, so the description carries the rest: it adds the persistence scope (V_t swarm namespace reachable by all agents), the optional TTL semantics, and the X-License-Key authentication requirement – genuine context beyond structured fields. It stops short of stating overwrite behavior for an existing key or concurrency/conflict handling for shared writes, which are the main remaining unknowns for a setter.

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 tight sentences with the action and scope front-loaded and no filler; the authentication note is tacked on the end but is still load-bearing information. Slight redundancy between 'persistent V_t swarm namespace' and 'accessible to all collaborative agents'.

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?

All six parameters are schema-documented and an output schema exists, so return values and parameter detail need no prose. The description covers auth, persistence scope, and TTL, leaving only overwrite and error semantics unstated – a modest gap for a shared-state write 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 six parameters including the type enum values and ttl_seconds defaults are already documented in the schema. The description only loosely echoes 'named typed' and 'optional TTL' without adding format or constraint detail, so the baseline 3 applies.

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

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

States a specific verb ('Stores') and a precisely scoped resource (a named typed variable/AST/symbol table/state object into the persistent V_t swarm namespace). It clearly contrasts with icx_var_get/icx_var_list by the write verb, though it never names those siblings or distinguishes itself from icx_remember or icx_swarm_state, which likely also persist state.

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?

'Accessible to all collaborative agents' implies the collaboration use case, and the persistence sweep in the namespace implies downstream reads via icx_var_get. However there is no explicit when-to-use / when-not, and nothing tells the agent whether to prefer icx_remember or icx_swarm_state for overlapping storage needs.

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

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

The description adds useful behavioral context beyond the annotations: in-process execution, direct Go host-function bindings, sub-100 microsecond latency, and X-License-Key authentication. However, the phrase "Mutating/read operation" is ambiguous for a tool with readOnlyHint=false, and it does not clarify side effects of mutating host functions such as icx_remember or icx_set_var.

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

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

The description is front-loaded with the core operation and then supplies relevant context about in-process execution and host bindings. It is somewhat dense and includes the ambiguous phrase "Mutating/read operation," but most sentences carry useful 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?

An output schema exists, so return values need not be explained. The description covers authentication, execution model, host functions, and latency context, though it could say more about side effects and sandboxing for a mutating execution 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 code, space_id, and timeout_ms are already documented in the input schema. The description reinforces that code can be WASM bytecode, WAT text, or an ICX script but adds no new syntax or format details 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 and resource: it executes compiled WebAssembly bytecode or WAT text in-process. It also lists the host-function bindings, making the tool's scope concrete, though it does not explicitly differentiate itself from the sibling icx_exec.

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 clear intended-use context by naming high-frequency trading and low-latency robotics and explaining that it avoids subprocess spawning and socket IPC. It does not explicitly state when not to use it or name icx_exec as the alternative, so it falls short of full alternative routing.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered and the description need only add context. 'Sub-5ms' and 'replaces external read tools' add a performance and substitution hint, but nothing about result limits, ranking behavior, or what the format modes produce.

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 no padding and the capability claim front-loaded. The brevity comes at the cost of specificity, but nothing is redundant or buried.

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 read tool with full schema coverage and readOnly annotation, the description is minimally sufficient. However, with no output schema, an agent has no idea what a recall result looks like, what 'ribbon' returns, or how depth changes the result, which the description should have addressed.

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 each of the four parameters is already documented in the schema, including depth, format, and space_id. The description adds no further meaning, and the unexplained 'ribbon' format in particular receives no elaboration beyond the schema text.

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?

It conveys a semantic-recall tool spanning tools, repos, issues and memory, but the core verb is buried under undefined jargon ('Voronoi topological walk'), which tells an agent nothing actionable. It also fails to distinguish itself from sibling recall tools such as icx_recall_scoped or icx_search_facts.

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 only usage signal is the claim 'Replaces external read tools', which gives no concrete trigger, no prerequisites, and no exclusions. It never says when to prefer this over icx_recall_scoped, icx_search_facts, or icx_multihop_walk, all of which sit 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?

readOnlyHint=true already tells the agent this is a safe read, so the description only needs to add context. It does add one meaningful behavioral trait — determinism plus a 'zero hallucination' claim, implying stable, reproducible output rather than generative variance — but the d^2 = 0 notation is unexplained jargon and there is no mention of return format, latency, or limits on input.

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

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

Two sentences, front-loaded with the domain scope, and no filler prose. It is dense with unexplained acronyms and mathematical notation, which costs some clarity, but it wastes no space.

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

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

There is no output schema, so the description carries the burden of explaining what a 'solve' returns — a CPA alignment table, a Middot classification, a chiastic structure? None of that is stated. For a multi-mode deterministic solver with three interacting parameters, an agent cannot predict the response shape or judge a correct invocation from this text 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%, and the schema itself documents all three parameters including enumerated example values for 'pair' and action strings for 'action'. The description adds no syntax, constraints, or interplay guidance (e.g. whether 'query' overrides 'pair'/'action'), so the 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 names a domain (CPA, Middot, chiastic folding) and asserts a deterministic solver, but never states operationally what the tool does with a query — it reads more like a marketing abstract than a verb+resource statement. It is clearly distinct from the icx_* knowledge-graph siblings, so there is no confusion risk, but the core action is left to inference from the name.

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, no prerequisites, and no exclusions. The presence of an 'ask' action inside the schema hints at a question-answering mode, but the description never explains when to pick that over cpa/middot/fold, nor when an agent should reach for this tool at all.

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