WhiteMagic — governed local memory for agent continuity

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

Annotations already declare idempotentHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is mostly covered. The description usefully adds that this is experimental/simulation and advisory-only with no proof verification or escrow. However, it leaves a real gap: readOnlyHint=false implies some side effect, yet the description never says what state (if any) 'settle' actually changes.

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 experimental/simulation tag front-loaded and the two outcome labels glossed inline. No filler; slightly dense parentheticals are the only cost.

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 must carry the return contract; it names the two outcomes but not the response shape or what the classification is actually derived from (string parity? hash? proof content). For a 3-parameter adjudication tool this leaves the agent guessing about inputs-to-outputs mapping.

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 three parameters are already documented, including that bid is a non-escrowed advisory label. The description reinforces the non-escrow nature of bid but adds no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (classify) and resource (payload or proof string) with two named outcomes, Cho (even/pass) and Han (odd/anomaly). The 'advisory only, no verification, no escrow' clause implicitly separates it from settlement siblings like economy_settle and economy_chohan_arbitrate, 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 exclusions ('does not independently verify execution proofs or perform on-chain escrow') imply when not to use it and point toward receipts.verify / economy_settle, but no alternative is named and no positive when-to-use condition is given. Usage must be inferred from the negative scope.

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, idempotentHint, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds useful framing ('zero-cost, real-time', what the no-lookup mode returns) but is silent on rate limits, data freshness windows, or how 'bulk' interacts with 'export' — a behavioral question an agent will actually face.

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 what the tool is and immediately followed by the two usage modes. No filler, no repetition of annotation-covered facts.

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-only query tool with a fully documented 3-param schema and no output schema, the description covers the primary lookup path well. It leaves a real gap around the third parameter combination — whether 'bulk' supersedes 'export', and what each export mode actually yields — which the agent must guess.

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

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

Schema coverage is 100%, so baseline is 3. The description reinforces 'lookup' semantics (IP, subnet prefix, HASSH fingerprint) and the omit-behavior, but that largely restates the schema's own parameter description and says nothing about 'bulk' or the export enum interplay.

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 ('Query ... threat intelligence and hostile-source indicators captured by the Citadel deception mesh') and names the two operating modes. It is clear what the tool does, though it does not position itself against any sibling (none of the listed siblings are close competitors, so this matters less).

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

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

Explicitly says to pass 'lookup' for target analysis and to omit it for rolling telemetry, campaign clusters, and advisory subnets — a genuine when-to-do-what split. It gives no guidance on when to use 'bulk' or which 'export' mode to pick, and no exclusions or prerequisites.

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

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

The description does disclose useful traits beyond annotations: local inference, grammar constraint with a 100% schema guarantee, no hallucination, and a signed receipt artifact. However, the parenthetical '(READ-ONLY: mutations refused)' directly conflicts with readOnlyHint=false in the annotations, which is only reconcilable if the receipt write is what makes it non-read-only. destructiveHint=false and idempotentHint=true partly mitigate, but the explicit read-only label is misleading.

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 clauses with the core action and guarantee front-loaded, and no filler sentences. The parenthetical read-only warning, while misleading, is at least placed where it will be seen.

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 should convey what a caller gets back; it mentions a signed deliberation receipt but not the decision/selection result or the receipt location semantics. With only three fully-described params it is close to adequate, but the read-only contradiction and thin return-shape explanation leave 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 100%, so intent, candidates, and emit_receipt are already documented in structured form. The description adds only the notion of 'ambiguous candidate options' and confirms the receipt, without clarifying the accepted shapes of candidates (array vs object) or when to disable emit_receipt.

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 (deliberate) and resource (ambiguous candidate options) and states the mechanism and side effect (grammar-constrained local SLM inference plus a signed deliberation receipt). It does not differentiate itself from close siblings like decision.shortlist or decision.outcome, which is left to the agent to infer.

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 'ambiguous candidate options' implies the usage condition (use when candidates are ambiguous rather than clearly ranked), but there is no explicit when-not, no prerequisite, and no named alternative such as decision.shortlist for non-ambiguous cases. 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?

The description declares '(READ-ONLY: mutations refused)' while the annotations declare readOnlyHint=false, i.e. this tool is not a pure read. Signing and journaling are inherently write operations, so the stated read-only guarantee directly conflicts with the structured safety metadata, leaving the agent unable to know whether calling it changes state.

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 action and resource in a single dense sentence, with the outcome enum values inline for quick scanning. The trailing parenthetical is short but misleading rather than wasteful, so it loses a point for content quality, not length.

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 6-parameter mutation tool with no output schema needs to say what it writes, where, whether it requires a prior dispatched receipt, and whether repeated calls are safe. Only the outcome values and the learning-loop intent are covered, and the contradictory read-only claim actively misleads about side effects.

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

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

Schema coverage is 67%, so the schema already documents most parameters. The description echoes the outcome values (success, failure, corrected) but omits 'unknown', and says nothing about receipt_path format, corrected_route semantics, or what tenant_id/session_id scope. Marginal value over 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 names a specific verb pair (sign and journal) and a specific resource (the outcome of a dispatched decision/shortlist receipt), and lists the outcome values it accepts. It implicitly distinguishes itself from decision.deliberate and decision.shortlist by operating on an already-dispatched receipt, though it never names those siblings 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?

It gives a purpose context ('for the learning loop') and implies you call it after a decision has been dispatched, but it never states preconditions (must a receipt exist first?), when not to call it, or which sibling to use instead for other decision lifecycle steps. 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?

Annotations already declare idempotent=true, destructive=false, openWorld=false, but the description adds genuinely new context: fully local execution (no network), no model forward pass, and emission of a signed receipt. The '(READ-ONLY: mutations refused)' framing sits in tension with readOnlyHint=false, though it is reconcilable — the only write is the receipt file, which the description does disclose.

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 dense, front-loaded sentences: capability first, behavioral constraints second. Nothing is wasted, though the trailing '(READ-ONLY: mutations refused)' parenthesis is the least informative part and introduces ambiguity given the receipt write.

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 10-parameter tool with no output schema, the description should say more about what comes back than 'a signed shortlist receipt' — e.g. whether ranked names, scores, and the top1-top2 margin/gate verdict are returned. The ambiguity gate behavior is only discoverable through the `margin_threshold` parameter description.

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% (k, state, routes, cascade, margin_threshold, emit_receipt all documented), so the schema carries parameter semantics and a baseline 3 applies. The description adds no parameter-level detail of its own, such as how `k` interacts with the ambiguity gate or what 'best match' scoring means numerically.

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 ('Rank candidate routes/actions for a state') plus the mechanism ('local static-embedding retrieval organ') and the side output ('signed shortlist receipt'). An agent can tell this is a cheap retrieval/ranking step, but the description itself never names a sibling (e.g. decision.deliberate) to contrast against — that contrast only appears in the `cascade` schema field.

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: 'no network, no model forward pass' signals a fast first-pass router, and 'cascade to System 1.5 Deliberator' (in the schema) hints at the escalation path. However, the description gives no explicit when-to-use / when-not-to-use rule versus decision.deliberate, sutra.route, or mandala.evaluate.

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 past the annotations by disclosing rate limiting (daily per-IP and global caps), the credit-ceiling mechanic ($0.10 start, +$0.25 per verified settled payment), and the fact that the returned pass is recall-scoped with hosted write gated behind a paid lease. It does not address failure/retry behavior, which matters given idempotentHint=false.

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 core action and ending on the return contract and the paid-lease caveat. Dense with jargon (recall-scope session pass) but no wasted sentences.

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, non-destructive mutation with no output schema, the description covers auth prerequisites, caps, credit mechanics, and the return artifact. The main gap is the absence of retry/idempotency guidance for a tool explicitly marked non-idempotent.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real meaning on top: the ceiling-growth rule explains how 'amount' is clamped, and 'bound to your authenticated evaluation key' explains the request_key provisioning path. It does not restate the max per-advance value, which the schema string itself contradicts (default 0.05 in schema vs. 'default 0.01' in prose).

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: 'Request a small uncollateralized compute advance.' The Phase 1 framing and 'recall-scope session pass' return make it distinguishable from economy_settle and economy_ledger, though it never names a sibling to route away from.

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 a clear conditional path: when calling without an existing authenticated key, set request_key to atomically provision one. It also scopes the tool to 'Phase 1 (2026-10-15)' and notes that hosted write requires a separate paid lease, which implicitly routes the agent elsewhere. No explicit 'do not use when' statement.

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 destructiveHint=false and idempotentHint=true, and the description goes further by disclosing that it acquires/enforces no locks, that its SHA-256 draw is post-hoc recomputable, and that it is not host-bias-proof. These are real behavioral caveats an agent could not recover from the structured fields, covering determinism and trust boundaries.

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 dense sentence with the scope constraint front-loaded and no filler; each clause carries a distinct caveat. It is slightly clipped and negative-heavy, which costs a little 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 7-parameter, nested-object tool with no output schema, the description covers the critical non-functional caveats but never says what is returned (a chosen contender? a draw value?) or how candidates/bids combine. With schema coverage complete, the remaining gap is the result semantics, which leaves it minimally 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 every parameter (bids, candidates, agent_a/b, client_seed(s), resource_id) is already documented in the schema with the same caveats the description repeats. The description adds no syntax, format, or interaction detail (e.g., candidates vs. agent_a/agent_b precedence) beyond the schema, so the baseline 3 applies.

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

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

Identifies the tool as an 'advisory contention tie-breaker,' which conveys the rough function, but the rest of the sentence is devoted to disclaimers rather than describing what it actually produces (e.g., which contender wins). It also never contrasts itself with the obvious sibling economy_chohan_roll or economy_advance, 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?

'Advisory contention tie-breaker only' implies the situation (resolving lock contention) and rules out enforcement uses, which is a partial when/when-not signal. However, no explicit condition selects this over economy_chohan_roll, economy_advance, or any other sibling, so the routing decision 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?

Annotations already establish readOnly, non-destructive, non-idempotent, closed-world behavior, so the bar is lower. The description still adds genuine value beyond them: it discloses the trust model (server seed revealed with the result) and an important caveat (no prior commitment and no host-bias proof), which tells the agent this randomness cannot be pre-verified.

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, front-loaded with the mechanism and followed by the fairness caveat. Nothing is padded, though the extreme brevity leaves useful detail (what the draw returns, how bet/client_seed interact) unaddressed rather than deliberately trimmed.

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 some burden for explaining the return value; it mentions that the server seed comes back with the result but does not describe the drawn outcome or shape. For a zero-required-parameter read-only tool this is adequate but 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%, so the enum meanings ('cho' = even, 'han' = odd) and the optionality of client_seed are already fully documented in the schema. The description adds no parameter syntax or semantics beyond that, 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 names a concrete mechanism ('SHA-256 dice draw') and implies a cho/han random outcome, but it never states plainly that it produces a random cho/han result for the caller. It also fails to distinguish itself from the sibling economy_chohan_arbitrate, so an agent cannot confidently route between the two from the description 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?

No when-to-use, when-not-to-use, or alternative guidance is given. With a nearby sibling (economy_chohan_arbitrate) that plausibly overlaps, the absence of any routing information is a real gap.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety and idempotency profile is fully covered. The description adds that the metrics are 'public' (implying no privileged access), which is modest extra context, but it does not describe the shape of the returned ledger or any time-window semantics.

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 listing the metric categories with no filler. It loses a point only because two of the listed items ('zero predatory liquidation policy', 'sovereign free invariants') are vague labels rather than concrete, interpretable outputs.

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, read-only inspection tool with fully populated safety annotations, the definition is adequate; it even gestures at the contents of the report. With no output schema, a slightly fuller description of the returned ledger structure would have helped, but nothing an agent needs to invoke it 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to disambiguate, and it correctly does not invent parameter 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 clear verb ('Inspect') and resource ('public transparency metrics') and enumerates the kinds of metrics returned (loans disbursed, default rates, liquidation policy). It does not reference any sibling tool, so the agent must infer why it should prefer this over economy_settle or gnosis.status. The phrase 'sovereign free invariants' is opaque jargon that weakens 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the many economy_* and gnosis.* siblings. The agent is left to infer that this is a read-only audit/inspection view, which the annotations imply but the description never states.

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=false, idempotentHint=true, destructiveHint=false, so the mutation/safety profile is covered. The description adds useful effect context (reputation upgrade, credit ceiling expansion) but omits what happens on partial settlement, whether funds must be pre-authorized, and failure/reversal behavior for a financial write.

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 core action front-loaded and the effect following immediately. No padding, though the second sentence could more clearly state how the two payment modes relate.

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 financial mutation with no output schema, the description conveys purpose and effect but leaves out the outcome of a successful settlement and the interaction between amount and outstanding balance. With annotations covering the safety profile, 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 coverage is 100%, so all four parameters are documented in the schema itself, including the omit-to-settle-full-balance semantics of 'amount'. The description's mention of 'payment reference or gasless EIP-3009 transfer authorization' names two modes but adds no detail beyond the schema; baseline 3 is correct.

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 ('Settle outstanding compute balance') and adds the consequence (reputation upgrade, credit ceiling expansion), so the agent knows what the call accomplishes. It does not distinguish this from siblings like economy_advance, which is presumably the opposite direction, so it stops 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?

Usage is implied by 'Settle outstanding compute balance' — an agent can infer it applies when a balance is owed. However, there is no explicit when/when-not guidance, no mention of prerequisites, and no routing between the two payment modes (payment_reference vs eip3009) despite them being alternatives.

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

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

The description asserts "READ-ONLY: mutations refused" for a tool whose annotations declare readOnlyHint=false and which is explicitly a create operation. With annotations present, this clause directly contradicts them rather than adding context, and no other behavioral detail (name uniqueness, idempotency, effect of the genesis beacon) is given.

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 brief and front-loaded, but the second sentence is actively harmful — a parenthetical that contradicts the tool's own function and annotations. Brevity does not compensate for a clause that misleads the caller.

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 creation tool with no output schema and an annotation profile covering mutability, the description should confirm what is created and any naming/precondition constraints. Instead it leaves the agent unsure whether the call will succeed at all, since the text claims mutations are refused.

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 both parameters (name, description) have their own constraints documented, so the description need not elaborate. It adds nothing about parameter meaning, which is acceptable at this coverage level.

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?

"Establish a new sovereign galaxy namespace with an initial genesis beacon" gives a specific create verb and resource, distinct from galaxy.fork and galaxy.list. The wording is slightly ornamental ("sovereign", "genesis beacon"), but the operation is identifiable.

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

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

No statement of when to use this versus galaxy.fork (clone an existing galaxy) or galaxy.list, despite those siblings being obvious alternatives. The only contextual clause is a self-contradictory parenthetical that gives no actionable routing 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?

The description claims '(READ-ONLY: mutations refused)' while annotations declare readOnlyHint=false, i.e. this is a write operation that creates a new galaxy. That is a direct contradiction that could lead an agent to call a mutating fork believing it is a safe read. The description also omits what is created, whether the source is modified, and any permission requirements.

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

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

A single front-loaded sentence with an inline example; nothing is padded. The trailing parenthetical is short but is the one element that does not earn its place, since it is misleading.

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

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

For a mutation with no output schema and no annotation-level detail about the result, the description says nothing about what the forked galaxy contains, whether the source partition is affected, or what happens on name collision. The read-only claim is unexplained and contradicts the annotations, leaving the agent less informed than the structured fields 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 description coverage is 100%, so both 'source' and 'target' are already documented with matching examples. The description's example mapping ('guide' -> 'project-alpha') and the word 'sovereign' add a hint that the branch is independent, but nothing beyond that, 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?

The description gives a specific verb and resource ('Fork an existing galaxy partition into a new sovereign galaxy branch') and a concrete example ('guide' -> 'project-alpha'). It is clear what the tool does, though it does not explicitly contrast with the sibling galaxy.create, which an agent would plausibly confuse it with.

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 fork versus when to use galaxy.create or galaxy.list, and no prerequisites or exclusions. Usage is only implied by the word 'fork', and the trailing '(READ-ONLY: mutations refused)' adds confusion rather than routing guidance.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description does not need to restate it. What it does add is real behavioral value: it discloses what the response contains (record counts, sample tags, starter guide status). It does not mention pagination or whether the result set is bounded despite "all active".

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 with no filler. The scope ("active") and the returned fields are front-loaded, and the sentence is neither padded nor truncated.

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 parameters and rich annotations, the only thing missing to make the tool callable is what it returns, and the description covers that since there is no output schema. The one gap is volume or pagination expectation when listing "all" active galaxies.

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?

This tool takes zero parameters, so there is nothing for the description to define and the baseline is 4. The description correctly does not invent any parameter-like language.

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 ("List") paired with a specific resource ("sovereign memory galaxies") and scopes the result to "active" ones. It also previews the returned fields, so an agent can distinguish it from galaxy.create and galaxy.fork. It stops short of explicitly naming those siblings as 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 word "active" implies this is the discovery view, and the natural reading is that you call this before creating or forking a galaxy. However, no sentence states when to use this, when not to, or what the alternative is. Usage is left to inference from the verb.

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 read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is clear. The description adds no behavioral detail beyond broad domains; it does not explain the claim booleans (is_spawn, is_write, etc.), evaluation semantics, or what an explanation 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 description is a single front-loaded sentence with no filler. It is concise and easy to parse, though its brevity contributes to under-specification rather than excess length.

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 seven optional parameters, no output schema, and non-obvious claim-evaluation fields, the description is too thin. It omits how concept, tool_name, args_hash, and the boolean claims combine, and gives no expectations about the returned explanation.

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 seven parameters are documented in the input schema. The description adds no parameter meaning and does not tie concept, tool_name, args_hash, or the claim fields to the explanation purpose. Baseline 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?

States the verb 'Explain' and three domains (architectural invariants, memory schemas, routing logic), so the general purpose is inferable. However, it does not say what inputs trigger each mode or how it differs from gnosis.status, leaving the scope broad.

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, when-not-to-use, prerequisite, or alternative-tool guidance is provided. The agent must infer that this is for internal conceptual explanation rather than memory search, session recall, or other sibling operations.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds no behavioral context at all - no indication of what 'invariant health' reports, whether it is cheap or expensive, or what a failing status looks like.

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 no padding, and 'health status' is placed at the end where it carries the most actionable meaning. Its brevity is not the problem; the vocabulary is.

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 input schema and no output schema, the description is the only place an agent can learn what this returns, and it does not say - 'system epistemics' and 'self-model calibration' are not interpretable outputs. For a status tool whose entire value is its return payload, this is a meaningful 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate and the schema is trivially complete. Baseline 4 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 phrase 'health status' signals a diagnostic read, but the leading clause 'System epistemics, self-model calibration' is abstract jargon with no verb and no resource the agent can concretely picture. It does not distinguish this from gnosis.explain or mandala.status, so an agent must guess at the actual output.

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 call this versus gnosis.explain or mandala.status, no prerequisites, and no exclusions. The only implied usage is 'check status', which the tool name already conveys.

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 tell the agent it is non-read-only, non-idempotent, non-destructive and closed-world; the description adds genuinely new context that the scores and token-budget deltas are modeled estimates rather than measured LLM execution. That caveat materially changes how an agent should trust the results. It still does not say what state, if any, is mutated or what the call returns, which keeps it below 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 experimental/simulation tag so the agent sees the most decision-relevant fact first. Dense terminology costs some readability, but nothing is redundant padding.

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

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

With no output schema, the description does the important work of telling the agent the outputs are modeled estimates, which is exactly the caveat that would otherwise be missing. For a 4-parameter simulation tool this is close to complete; only the side effects of 'summoning' clones remain unstated.

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 schema already documents edict, clones, peer, and archetype. The description only adds marginal value by grouping the four archetype values conceptually; it gives no extra syntax or format detail beyond the schema's examples.

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 ('Run a deterministic Rayon stack-codon cohort simulation') and names the four archetypes it evaluates, so an agent learns what actually happens. The jargon is heavy, but the bracketed '[Experimental / Simulation]' tag disambiguates it from real dispatch tools. It never names a sibling to contrast with, so differentiation stays 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 '[Experimental / Simulation]' prefix implies this is for experimental what-if evaluation rather than production execution, which is useful implied guidance. However, it never says when to pick this over sutra.cast, chohan.settle, or economy_chohan_roll, all of which appear to touch overlapping codon/Cho-Han concepts.

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 says 'READ-ONLY: mutations refused', but the annotations explicitly set readOnlyHint=false. This is a direct contradiction about whether the tool performs a read-only operation or executes a mutation. The description also adds sandbox and notarization concepts, but the fundamental safety profile is contradictory.

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 short and front-loaded with the main action, which is good. However, the parenthetical creates structural confusion by placing a contradictory constraint after the main clause rather than clarifying whether the tool executes or refuses mutations.

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, the description should clarify what 'notarize with Spec 0.5 receipt' returns and what an agent should expect after evaluation. It also leaves the read-only contradiction unresolved, so the agent lacks enough context to invoke this 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 candidate_id, command, and mutation_kind are already fully documented by the schema. The description does not add any further meaning about parameter interactions, defaults, or enum behavior 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 names a specific action (execute a candidate mutation) and sandbox/notarization context, but the parenthetical 'READ-ONLY: mutations refused' directly conflicts with the apparent purpose of executing mutations, making the tool's actual role ambiguous. It also does not distinguish mandala.evaluate from siblings like mandala.triage or mandala.status.

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

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

There is no guidance on when to use this tool versus alternatives such as mandala.triage, mandala.status, or receipt tools. The parenthetical hints at a restriction, but it does not state the conditions for invoking this tool or what to do instead when mutations are refused.

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, idempotentHint, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds genuine value by enumerating the reported dimensions (ABI level, rlimit bounds, capability ledger), which the annotations do not convey; it stops short of noting cost, freshness, or snapshot semantics.

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

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

A single front-loaded sentence with no filler; every clause names a distinct reported facet. It is terse and efficient, though the dense jargon (microsecond Landlock, capability ledger) assumes domain familiarity.

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

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

With no output schema, the description carries the burden of indicating what comes back, and it does so by listing ABI level, rlimit bounds, and capability ledger. For a zero-parameter, read-only status call this is close to sufficient; return shape and format remain 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?

The tool takes zero parameters and the schema is closed (additionalProperties: false), so there is no parameter semantics to explain. The baseline of 4 applies; the description correctly does not invent parameters.

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 the resource (Mandala Landlock sandbox) and the specific facets it reports: ABI level, POSIX rlimit bounds, and capability ledger. It is clear what the tool returns, but nothing distinguishes it from nearby siblings like mandala.evaluate, mandala.triage, or gnosis.status.

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

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

Usage is only implied by the word 'Status' — an agent can infer this is a read of current sandbox posture, but there is no explicit when-to-use, no prerequisite, and no statement of when to prefer mandala.evaluate or gnosis.status instead.

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 idempotent=true, destructive=false, openWorld=false, so safety is largely covered; the description adds useful latency ('<30 ns') and non-autoregressive/'System 1' framing. However, readOnlyHint=false implies some state effect while the description only describes classification and prediction, leaving it unclear whether anything is recorded or emitted.

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 no padding, so it is structurally efficient, but the density is spent on undefined acronyms rather than on information the agent can act on. Brevity here costs comprehension rather than buying it.

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?

It does gesture at the three outputs an agent would need (classification, marginal utility prediction, confinement tier), which partly compensates for the absence of an output schema. What is missing is any explanation of what the tiers mean or how the results should be interpreted, which matters for a five-parameter decision gate.

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 five parameters (cost, risk, inquiry, utility, variance) are already documented with ranges and a default. The description adds no interpretation of how these inputs drive the classification or how the utility threshold interacts with the predicted marginal utility, 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?

The verb phrase 'classify tasks and predict marginal utility and confinement tier' is specific enough to grasp the operation, but it is wrapped in opaque jargon ('Non-autoregressive System 1 JEV/Layla triage gate') that an agent cannot resolve without outside knowledge. Nothing distinguishes it from nearby siblings such as mandala.evaluate or decision.shortlist.

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 gate versus mandala.evaluate, decision.deliberate, or decision.shortlist, all of which sit in the same decision/triage space. No prerequisites, thresholds, or exclusion 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds useful behavioral detail by stating that unsupported field/op combinations are refused, which is not captured in the annotations.

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

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

The description is compact and front-loaded, moving immediately from the aggregation scope to supported operators and field categories. There is no filler, and every clause contributes to selecting or invoking the tool correctly.

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 definition covers aggregation scope and supported field/operator combinations, but it does not clarify whether categorical-field counts return a single total or grouped counts, nor does it describe the return shape. With no output schema and a moderately complex aggregation surface, this leaves some ambiguity.

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, including the field/operator compatibility and limit default. The description largely restates the schema's field categories rather than adding new parameter-level meaning.

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: 'Aggregate over the matched record set' and names the supported numeric/categorical fields and operators. It is clear what the tool does, though it does not distinguish itself from nearby siblings such as memory.count or memory.stats.

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 tool is for aggregation, but gives no explicit guidance on when to use it versus alternatives like memory.count, memory.filter, or memory.stats. It also provides no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered without description help. The description contributes only the concepts of hub penalization and multi-hop activation — no explanation of what a 'hub' is, how penalization affects ranking, or what the returned neighbours look like (no output schema exists to compensate).

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

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

A single front-loaded sentence with no filler. It is efficient, though the density of undefined domain jargon ('hub-penalized spreading activation') reduces its usefulness per word rather than improving it.

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 5-parameter traversal tool with no output schema leaves the description responsible for explaining what comes back — ranked neighbours, activation scores, edge metadata — and it says none of this. The safety behaviour is covered by annotations and the parameters by the schema, so it is minimally viable but clearly incomplete on return shape and result ordering.

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

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

Schema description coverage is 100%, so id, hops, decay, limit and direction are all fully documented in the schema, setting the baseline at 3. The description's 'multi-hop' and 'hub-penalized' hints loosely map to hops and decay but add no operational detail beyond what the schema already gives.

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 — 'Traverse associative graph neighbours of a memory' — which is distinguishable from memory.read/search/list siblings because it implies graph traversal rather than record retrieval. However, 'hub-penalized multi-hop spreading activation' is unexplained jargon that adds obscurity rather than clarity, 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?

No indication of when an agent should choose this over memory.search, memory.hybrid_recall, memory.filter, or memory.aggregate, all of which could plausibly return related memories. There are no stated preconditions, exclusions, or 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, idempotentHint=true, destructiveHint=false and closed-world, so the safety profile is fully covered. The description adds only the batching trait, and says nothing about behavior on missing/invalid IDs, result ordering, or partial-failure semantics.

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 well-formed sentence with the resource and the batching benefit front-loaded; no filler and nothing 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 two-parameter read tool with rich annotations this is close to adequate, but with no output schema the description could have said what a batch read returns or how missing IDs are handled. It is minimally sufficient but leaves real 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 100%, so both parameters are already documented, and the description merely restates that IDs may be UUIDs or integers. It adds no meaning for the 'galaxy' parameter (default codex) or constraints on list size/ordering, 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?

Specific verb ('Read') plus resource ('multiple memories') and an explicit scope qualifier ('in a single call'), which clearly separates it from the singular memory.read sibling. It stops short of naming memory.read or memory.search_batch directly, so the differentiation is implied rather than stated.

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 'in a single call' hints that this is the efficient option when fetching many memories, but there is no explicit when-to-use, when-not-to-use, or named alternative (memory.read, memory.search_batch, memory.filter). Usage must be inferred by 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?

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior. The description adds a useful behavioral trait beyond annotations: it returns only a count and omits full payload content, which tells the agent about response size and 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 efficient sentence, front-loaded with the verb and the key differentiator. No filler or repetition.

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

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

For a one-parameter, read-only count tool with rich annotations and full schema coverage, the description is nearly complete. It could mention the optional filter dimension (galaxy) or name sibling alternatives, 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% and the single 'galaxy' parameter is fully documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, so 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 (count) and resource (memories) with a clear scope qualifier ('matching optional filters'). It implicitly distinguishes from sibling list/query tools by noting 'without returning full payload content,' though it does not explicitly name alternatives like memory.list or memory.stats.

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: use when you need a count of filtered memories but not the full records. There is no explicit statement of when to use this versus memory.stats, memory.aggregate, or memory.list, nor are there exclusions or prerequisites.

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

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

The description declares "(READ-ONLY: mutations refused)" while the annotations set readOnlyHint=false and the tool is a store/create operation. This directly contradicts the structured metadata and would mislead an agent about whether the call mutates state. The remaining claims about 6D projection and bijective UUID disclose nothing an agent can act on.

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 short, but the two sentences include a self-contradictory parenthetical and marketing jargon that distract rather than front-load the useful information. Every sentence should earn its place; the read-only clause actively harms comprehension.

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 eight-parameter mutation tool with no output schema and no annotations covering mutation semantics, the description should clarify write behavior, defaults, and what gets persisted. Instead it leaves a direct contradiction about mutation and provides no return or persistence context.

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

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

Schema description coverage is 100%, so all eight parameters (galaxy, source, event_time, importance, etc.) are already documented in the schema. The description adds only a vague "galaxy routing" mention and no syntax or default detail beyond what the schema states. Baseline 3 is appropriate when the schema carries the 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 verb+resource pair "Store a new memory" is clear, and the galaxy hint distinguishes it slightly from read siblings. However, the rest of the sentence is opaque jargon ("holographic substrate", "bijective UUID", "6D projection") and the trailing "(READ-ONLY: mutations refused)" actively muddies what the tool does, leaving the agent unsure whether it actually 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?

No guidance on when to use this versus the many nearby write/ingest siblings such as memory.ingest, memory.update, session.record, or memory.batch_read. The parenthetical about read-only refusal gives no actionable routing, and there are no stated prerequisites 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?

The annotations already declare read-only, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds no behavioral detail beyond what the annotations and schema provide, such as ordering, pagination behavior, or result 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?

It is a single front-loaded sentence with no filler. The parenthetical examples are compact, and no sentence is wasteful.

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?

Rich schema descriptions and safety annotations compensate for much of the brevity, and no output schema exists. However, for a ten-parameter filtering tool with many memory siblings, the one-sentence description leaves material gaps around filter combination, defaults, and tool selection.

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 ten parameters. The description mentions tags, minimum importance, and recency, but it does not add syntax, combination semantics, 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 description states a specific verb and resource: filter memories. It also names example filter facets, but it does not distinguish this tool from close siblings such as memory.query, memory.search, memory.list, or memory.hybrid_recall.

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 explicit guidance on when to use this tool versus alternatives, nor when not to use it. The agent is left to infer that this is for metadata-based filtering from the description alone.

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, idempotentHint, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds that results come from hybrid BM25/dense fusion and that this is an alias, but it does not mention return format, pagination, scoring behavior, or cold-recovery semantics.

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. Every word serves to identify the alias relationship and fusion method.

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 12 parameters, no output schema, and rich annotations/schema descriptions, the description is minimal. It covers the alias and fusion nature but leaves the agent to infer return shape and practical selection guidance from memory.search or 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 all 12 parameters are already documented in the schema. The description adds no parameter-specific meaning beyond the schema, which is appropriate for this 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 explicitly identifies the tool as a compatibility alias of memory.search and names the retrieval mechanism (BM25 + dense vector fusion). This makes the resource and method clear, though it does not spell out the action verb or when an agent should choose this alias over the canonical memory.search 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?

The phrase 'Compatibility alias' implies the tool exists for backward-compatibility scenarios, but the description never explicitly says when to use it versus memory.search or when to avoid it. Usage is only implied, not 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?

The description asserts '(READ-ONLY: mutations refused)' while the annotations declare readOnlyHint=false for a tool whose entire purpose is writing memories. This directly misleads the agent about the tool's side effects. The otherwise useful notes ('returns real counts', 'refuses malformed input') are eclipsed by the contradiction.

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

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

A single dense sentence that front-loads the accepted input forms, which is good. But the trailing parenthetical is both misleading and costs space that could have carried the dry-run default, so the sentence does not fully earn its length.

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?

Eight optional parameters, no output schema, and no annotations the agent can rely on given the contradiction. Most importantly, the description omits that dry_run defaults to true, meaning a naive call may write nothing – a critical fact for correct invocation that the schema states only tersely.

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 baselines at 3. The description does usefully group the four input variants (items / items_jsonl / text / source) into one sentence, but adds nothing about the behaviorally decisive parameters: dry_run defaulting to true and redact defaulting to true.

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 (batch ingest into memory) and enumerates the accepted input forms (items / items_jsonl / text inline, or source file) routed via the batch-create path. It is distinguishable from memory.create only obliquely, via 'batch-create path'; it never names a 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?

There is no statement of when to choose this over memory.create, memory.update, memory.batch_read or the search tools. The batch-vs-single distinction with memory.create is only hinted at by the phrase 'batch-create path', leaving the agent to infer the selection rule.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without the description. Beyond that the description only restates the schema parameters and says nothing about result ordering, default sort, whether pagination is stable across calls, or what a returned memory 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?

A single front-loaded sentence with no filler or repetition. It is efficient, though the terseness comes at the cost of the usage and return-format context an agent would benefit from.

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-only list tool with full annotation and schema coverage, the essentials are present. However, with no output schema, the description is the only place to describe what a listing returns and in what order, and it says nothing about either.

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 and the schema already explains defaults for limit and offset and the omit-for-all-galaxies behavior. The description adds no syntax or format detail and notably omits exclude_tags entirely, so it does not improve on the structured data.

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 ('List memories') and states the two axes of control (pagination and galaxy filtering), so the basic purpose is unambiguous. It does not differentiate from the many closely related siblings such as memory.filter, memory.query, memory.search, or memory.batch_read, which is the only thing keeping 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?

There is no statement of when to use this tool versus memory.filter, memory.search, or memory.aggregate, and no prerequisites or exclusions. The agent must infer from the name alone that this is the unfiltered enumeration path, which is exactly the inference the description should remove.

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 explicitly says '(READ-ONLY: mutations refused)' while the annotations declare readOnlyHint=false. It also describes mutating actions ('pin', 'release it with pinned=false'), directly contradicting the read-only claim. This is a serious inconsistency that could mislead an agent about whether the tool mutates data.

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 front-loaded sentence with minimal waste. The core action and release option are stated immediately. The contradictory READ-ONLY parenthetical detracts from an otherwise efficient 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?

This is a mutation tool with no output schema and only annotations covering some safety traits. The description omits what happens on success or failure, what galaxy mismatch refusal returns, and how the protection interacts with memory lifecycle operations. The contradictory read-only claim further undermines completeness.

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 id, galaxy, and pinned in detail. The description reinforces the pinned=false release behavior but adds no meaning beyond the schema, such as galaxy mismatch handling or UUID formatting. Baseline 3 is appropriate when the schema carries 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 clearly states the specific operation: durably pinning a memory against decay, sweep compaction, and forgetting, or releasing it. The verb and resource are unambiguous. It does not explicitly distinguish this from siblings such as memory.update, which could also modify memory state, 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?

It implies when to use it by naming the condition 'critical memory' and explains that pinned=false releases the pin. However, it gives no explicit when-not guidance, prerequisites, or alternatives such as memory.update or memory.create, leaving usage context largely inferred.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds little beyond that and misleadingly claims 'ordering' and 'field projections' that are absent from the schema (which has additionalProperties=false), so it does not reliably describe actual 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 front-loaded sentence with no wasted preamble, which is good. However, the phrase 'ordering, and field projections' does not earn its place because those capabilities are not in the schema, making the brevity partly misleading.

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 eight optional parameters and no output schema, the description should explain what the query returns and how filters combine (e.g., AND semantics for tags). It also fails to differentiate this tool from several similar memory-query siblings, leaving significant context 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 100%, so the schema already defines all eight parameters. The description adds no parameter semantics and instead mentions ordering and field projections that are not present in the input schema, which risks confusing the agent rather than clarifying parameter meaning.

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 clear verb (query) and resource (memories) and mentions filters, so an agent knows the general operation. However, it does not distinguish this tool from siblings like memory.search, memory.filter, memory.list, or memory.hybrid_recall, leaving ambiguity about which query tool to pick.

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 memory.search or memory.filter, nor any exclusions or preconditions. The word 'structured' hints at a use case but does not route the agent explicitly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds little beyond the identifier lookup behavior and does not mention authentication, rate limits, or return 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?

A single front-loaded sentence with no wasted words. It gives the essential action and identifier forms immediately.

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-only lookup with full schema descriptions and rich annotations, this is nearly complete. It could optionally mention the galaxy filter or return shape, but neither is essential for correct invocation.

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

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

Schema coverage is 100%, so both parameters are documented in the schema. The description reinforces the id parameter as UUID or numeric record ID, but does not add meaning for the optional galaxy filter 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 and resource: retrieve a memory by numeric record ID or UUID. This implicitly distinguishes it from search/list/filter siblings, but it does not name an alternative 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 identifier-based retrieval implies when to use it, but there is no explicit guidance on when not to use it or which sibling to choose instead, such as memory.search or memory.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?

Annotations already declare readOnly, idempotent, and non-destructive, so safety is covered. The description adds genuinely new behavioral context by explaining that 'verify' is not a plain read but a recomputation of content hashes and chain links, which tells the agent the call does work and could be costlier. It stops short of noting that verification may surface mismatch results or fail on a broken chain.

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, front-loaded with the primary action and resource, with the secondary verification mode immediately following. Nothing is redundant and no sentence needs trimming.

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 parameters, full schema coverage, and no output schema, the definition covers what an agent needs to select and invoke it. It is slightly thin on what a listed revision entry contains and on what a failed verification looks like.

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 pushes it higher by explaining what the 'verify' enum value actually does (hash recomputation plus chain-link checks), giving meaning beyond the schema's bare "'verify'" label, though it does not clarify the id format or expected scale of 'list'.

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 pair (list / verify) against a specific resource (the durable revision chain of a memory), which is clearly distinct from siblings like memory.read, memory.list, or memory.associations. An agent can tell what this returns without opening the 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?

The description distinguishes the two modes of use: 'list' to inspect the chain and 'verify' to check integrity, and the schema marks 'list' as the default. It gives clear context for choosing an action but names no alternative tools or when-not conditions.

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 readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds useful context on ranking mechanism and deterministic sub-millisecond latency, but says nothing about how default filtering behaves (historical=false, cold records) or how scoring/ranking affects results.

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

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

A single front-loaded sentence with zero filler and the core mechanism stated up front. It is efficient, though its brevity leaves little room for the routing and parameter context the tool actually 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?

For a 13-parameter search tool with no output schema and a dense set of sibling search tools, one sentence is thin. The schema carries the parameter burden, but nothing explains result ordering, cross-galaxy discovery, cold recovery semantics, or when this tool beats memory.query/memory.hybrid_recall.

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 13 parameters are already documented in the schema, which sets the baseline at 3. The description adds no parameter-level meaning beyond that — it never mentions limit, time bounds, galaxy scoping, or the trust/importance floors.

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 ("Search memories") and adds the retrieval mechanism (hybrid BM25 + vector fusion), so the agent knows exactly what it does. However, it offers no differentiation from close siblings like memory.query, memory.hybrid_recall, memory.filter, or memory.search_batch, leaving ambiguity about which to pick.

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 versus the many overlapping siblings (memory.query, memory.hybrid_recall, memory.filter, memory.search_batch). No prerequisites, no exclusions, no scenario framing — the agent must infer selection from names alone.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds the concurrency and 'sub-millisecond retrieval' performance traits, which is modest added value, but omits execution-related behavior such as whether queries run in parallel with a shared limit or how partial failures are handled.

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

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

A single front-loaded sentence with no filler; the concurrency behavior comes before the performance claim. It is efficient, though the extreme brevity leaves gaps that other dimensions penalize.

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 the description says nothing about the return shape - critical for a batch tool where an agent needs to know whether results are aligned index-wise to the input queries or flattened. Combined with no guidance on ordering, partial failures, or aggregate vs per-query limits, the description is under-specified for a batch API.

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%, including the default of 5 for 'limit', so the schema already carries parameter meaning. The description adds nothing beyond it - notably no statement about whether 'limit' applies per query across the whole batch in aggregate. 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 names a specific verb ('Execute') and resource ('multiple memory search queries') and makes the batch nature explicit via 'concurrently', so an agent can tell it apart from the single-query memory.search sibling. It stops short of naming that sibling directly, so the differentiation is inferential rather than stated.

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 phrase 'multiple memory search queries' hints that this is the tool for multi-query workloads, but there is no explicit when-to-use, no when-not, and no named alternative such as memory.search for single lookups. An agent must reason about the batch/single split on its own.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by naming the metrics returned, including crash-consistency invariants, but it does not describe output shape, formatting, or scoping behavior beyond the schema.

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 text. It is dense with jargon but efficiently conveys the metric categories, though it reads as a fragment rather than a complete usage statement.

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-only statistics tool with a fully documented single parameter and no output schema, the description supplies enough detail about what is returned. The main omission is that 'crash-consistency invariants' remains ambiguous without a clearer explanation of the result structure.

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

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

There is one optional parameter and schema description coverage is 100%, so the schema already documents the galaxy argument and its default. The description does not add meaning beyond the schema, which puts it at the baseline for high schema coverage.

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

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

The description clearly identifies a statistics tool and enumerates specific metrics (epoch, total records, relations, postings, crash-consistency invariants). It does not explicitly distinguish itself from nearby siblings such as memory.count, memory.aggregate, or memory.list, so it stops 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 provides no when-to-use guidance, prerequisites, or comparison to alternatives. An agent can infer that this is for statistics, but there is no explicit routing between this tool and memory.count or memory.aggregate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds only that usage counts are included in the output, which is useful but thin context beyond the structured data.

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

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

A single, front-loaded sentence with no wasted words and the key output detail (usage counts) included. It is appropriately sized for a two-optional-parameter list tool.

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 and no output schema, the description is minimally adequate: it hints at return contents (tag plus count) but doesn't clarify ordering, whether counts are global or galaxy-scoped, or how limit interacts with results. Enough to call it, not enough to predict its output precisely.

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 limit and galaxy are fully documented in the schema, establishing the baseline of 3. The description adds no further semantics about defaults, galaxy scoping behavior, or ordering of results.

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?

"List the tag vocabulary with usage counts" gives a specific verb (List), a specific resource (tag vocabulary), and a scope qualifier (usage counts). It is clearly distinguishable from nearby siblings like memory.stats or memory.filter, though it doesn't explicitly name 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 guidance on when to use this versus memory.stats, memory.aggregate, or memory.filter, all of which could plausibly surface tag-like information. The agent must infer the use case entirely from the single-line purpose.

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 clause 'results are evidence, not verified facts' is genuinely valuable — it tells the agent how much to trust the output, which the annotations do not convey. However, it omits what 'statuses' mean, how scoping/namespace isolation works, or why a pure query carries readOnlyHint=false and idempotentHint=false; that annotation profile sits uneasily with a 'Query' verb and is left unexplained.

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 trust caveat placed after the scope statement — no filler. It is arguably over-compressed for a 6-parameter tool with three undocumented params, but every word 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 six parameters, no output schema, low schema coverage, and no annotations explaining the read/non-read status, the description should at minimum define the three modes and the temporal semantics. As written, an agent cannot call this correctly without reverse-engineering 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 coverage is only 33%: known_at and valid_at are well documented in-schema, but mode, subject, namespace, and predicate have no descriptions anywhere. Critically, the description never explains what current/history/as_of actually return, which is the single most decision-relevant parameter for this tool.

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 ('scoped temporal source assertions and their statuses'), which is more precise than a generic memory read. It does not, however, distinguish itself from close siblings such as memory.query, memory.revisions, or memory.hybrid_recall, so an agent must infer the boundary from the word 'temporal' 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 when-to-use guidance, no statement of when NOT to use it versus memory.query or memory.revisions, and no prerequisites. The only routing signal is the adjective 'temporal' and the mode enum in the schema, which the description never references.

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 asserts '(READ-ONLY: mutations refused)', but the annotations declare readOnlyHint=false, i.e. this tool performs writes. That is a direct contradiction about whether the call will mutate state at all, which is the single most important behavioral fact for the agent. The otherwise-useful details (hash/timestamp/reason revision entry, supersede-vs-consolidate semantics) cannot offset the conflict.

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 dense sentence that front-loads the action and mechanism, followed by a short parenthetical. Nothing is padded, though the parenthetical is the contradictory element and would have been better spent on a non-conflicting operational note.

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 the description does explain what side effects are created (superseding record plus revision entry with hashes and timestamp), which is the right content for a mutation tool. However, the read-only claim leaves the agent unable to tell whether the call will succeed or be refused, so the definition is not fully sufficient to act on.

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

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

Schema coverage is 100%, so baseline is 3; the description still adds real meaning by framing `content` and `superseded_by_id` as two different modes (writing a new superseding record vs consolidating into an existing target) and by tying `reason` to the durable revision entry. This is genuine value beyond the per-field 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?

States a specific verb (update) and resource (memory) plus the mechanism used: writing a superseding record or consolidating, plus a durable revision entry. That mechanism distinguishes it from memory.create and memory.revisions without needing to name them, though no sibling is explicitly called out.

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 'Update an existing memory' and the required `id`. There is no statement about when to choose this over memory.create, memory.pin, or memory.aggregate, and 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds only the transport protocol ('sovereign TCP'), while leaving key behavior unexplained: sync direction (push/pull/bidirectional), conflict handling, whether the call blocks, and what part of state is synchronized.

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

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

A single front-loaded sentence with no wasted preamble. Slight deduction for the ambiguous jargon 'Substrate' and 'sovereign TCP protocol', which adds flavor rather than actionable clarity.

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 mutating, potentially long-running synchronization operation with no output schema, the description leaves significant questions unanswered: what data is synchronized, which direction, how conflicts resolve, and what the caller observes on completion. Annotations cover safety but not operational semantics.

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 both parameters documented in-schema (peer address format, batch_size default). The description adds no additional meaning about those parameters, so the baseline 3 for full schema coverage 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 verb (Synchronize) and resource (the Substrate) and specifies the target (a remote peer node). However, domain jargon like 'Substrate' and 'sovereign TCP protocol' is not unpacked, and there is no explicit differentiation from any sibling tool, though none of the siblings appear to overlap 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?

There is no guidance on when to use this tool, when not to, or which sibling to prefer. The name hints at mesh synchronization, but an agent must infer all usage conditions and prerequisites (peer reachability, auth, direction of sync) from nothing.

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 this is not read-only, not idempotent, not destructive, and closed-world. The description adds meaningful behavioral context beyond those hints: it explains what gets signed for each kind, that 'session' covers the last limit turns, and that 'state_transition' is chained to the prior emitted receipt.

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-loaded, with two sentences that each carry useful information. It includes the key kind distinction and the unsupported 'task' case without wasted wording.

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

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

For a non-read-only tool with no output schema, the description does a good job explaining the two receipt kinds and the chaining behavior. It still does not describe the return value or whether the receipt is returned directly versus only written, but the essential invocation context is covered.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description reinforces that 'limit' applies to session-log turns for kind 'session' and clarifies kind behavior, but it does not add much parameter detail 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 specific verb and resource: emit a signed continuity receipt. It then distinguishes supported receipt kinds and explicitly rules out 'task' receipts, which lets an agent identify the tool's domain without opening the 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?

The description implies usage through its explanation of 'session' versus 'state_transition' receipts and notes that 'task' is unsupported. However, it does not explicitly say when to choose this tool over the obvious sibling receipts.verify or other session continuity tools, so guidance remains mostly 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?

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered; the description adds non-obvious context beyond them: verification depends on an existing local gate key and only accepts supported profile types (including session/state_transition continuity receipts). It does not disclose what a failed verification looks like (error vs. result flag), which is a remaining gap with no output schema.

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: the positive scope first, then the exclusion. No redundancy and nothing to trim.

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?

Annotations are rich and the parameter is documented, but with no output schema the agent gets no indication of the result shape or failure behavior, and the `bundle` object has an undefined nested structure with additionalProperties false. The description could have pointed to receipts.emit/session.continuity as the source of a valid bundle, which would have closed the remaining 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 description coverage is 100% and the single `bundle` parameter is already documented as 'One supported signed WhiteMagic profile receipt object'. The description adds modest value by naming which profile receipts are acceptable, but the nested bundle object has no defined properties and the description does not describe its expected internal shape.

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 (verify) and a specific resource (one supported WhiteMagic receipt profile) against a named trust anchor (the existing local gate key). The negative clause clarifies it is not a general bundle verifier, though it never explicitly contrasts with the closest sibling, receipts.emit.

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 an explicit exclusion — 'This is not a general Continuity Receipt bundle verifier' — which tells the agent when to look elsewhere, and the 'one supported profile' phrasing implies the input must be a single known receipt type. It stops short of naming the alternative tool for general bundle verification.

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 disclose non-read-only and non-idempotent behavior, while the description adds useful operational context: persistent per-client-IP and global daily issuance limits, term sourcing from the authoritative key record, and Bearer-token usage. It does not cover error cases or key expiry, but it meaningfully exceeds 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?

The description is four short sentences, front-loads the primary purpose, and each sentence adds distinct value: purpose, limits, terms, and authentication usage.

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 two-optional-parameter tool with no output schema and clear annotations, the description covers the essential operational details. It could more explicitly describe the response shape, but the agent has enough to call it correctly.

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

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

Schema coverage is 100% and both optional parameters are fully documented in the input schema. The description adds no parameter-specific meaning, 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 states a specific verb and resource: request a free evaluation API key in-band. No sibling tool handles key issuance, so the agent can distinguish this tool from all listed siblings without inspecting schemas.

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 tool is used when an evaluation key is needed and explains how to use the returned key, but it gives no explicit when/when-not guidance or alternatives. The usage context is understandable but not fully 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?

The description asserts "(READ-ONLY: mutations refused)" while annotations declare readOnlyHint=false and the name/title say "Save". This directly contradicts the structured safety signal and gives an agent no reliable basis for deciding whether calling this mutates state. It also omits any behavioral detail about what a checkpoint write affects or what constitutes a refused mutation.

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 purpose front-loaded, which is the right shape. The trailing parenthetical, however, is pure cost: it is both misleading and appended as an afterthought rather than integrated into a coherent statement of effect.

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 ten-parameter write-shaped tool with no output schema, the description should say what comes back (a checkpoint ID? a path?) and whether any fields are effectively required for a usable handoff. Those gaps would matter less if the annotations were trusted, but the description has actively muddied the side-effect profile instead of clarifying 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 coverage is 100%, so all ten parameters including session_id, crystallize, and tests_green are already documented in the schema and nothing needs compensating. The description restates a subset of the payload fields but adds no semantics beyond the schema text, 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 ("Save a structured checkpoint") and enumerates the payload contents (summary, git state, next queue, open flags, track/lease metadata), which makes the intent unambiguous. It never names which sibling it competes with (session.record, session.continuity, session.digest, memory.create), so an agent cannot differentiate it from those without opening the schemas.

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?

"for lossless handoffs" implies the situation that selects this tool, but no explicit when-to-use rule, prerequisite, or exclusion is given. With five closely related session.* siblings in the list, the agent is left 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?

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is largely covered, but the description never explains why a 'Recall' is not read-only (e.g., it may persist a continuity record) — an agent could be surprised by side effects. It does usefully disclose what gets surfaced, but says nothing about cost, latency, or payload size for the returned blocks.

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

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

A single front-loaded sentence with no filler; every listed item names an actual returned section. Slightly dense with domain jargon (DiAML arcs, track crystals) that an unfamiliar agent must infer, which keeps it off 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?

With 10 optional parameters and no output schema, the description carries the burden of describing return content, and it does enumerate the returned blocks. What is missing is any hint of the response shape (agent_context.text, briefing.text) or ordering, though the schema's parameter text partly compensates.

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% across all 10 parameters (n, since/until, track, token_budget, byte caps), so the schema carries parameter meaning fully. The description only indirectly hints at parameters by naming outputs like 'track crystals', adding little beyond the structured fields; 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 verb 'Recall' plus a concrete scope ('where the previous session left off') and an explicit enumeration of the returned blocks (recent turns, anchors, DiAML arcs, crystals, checkpoints, queues) makes the purpose unambiguous. However, it never distinguishes itself from the very close sibling session.recall, nor from session.replay/digest/checkpoint, so an agent cannot tell from the description alone which of these to pick.

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 'where the previous session left off' implicitly signals the resumption/start-of-session scenario, which is the only usage cue. There is no explicit when-to-use, no exclusions, and no named alternative despite six session.* siblings with overlapping recall semantics.

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, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds useful context beyond that: the output shape ('markdown text plus JSON') and the existence of an optional codex crystallization path. It does not disclose that crystallization writes a linked memory record, which is a meaningful side effect worth flagging given the readOnly 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?

A single front-loaded sentence with no filler; the action and inputs come first. It is slightly dense with domain jargon ('typed', 'codex crystallization') that a new agent may not parse, 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?

With no output schema, the description does partly cover the return format, which is the right instinct. It still leaves unclear what a 'checkpoint' contains, how turns and checkpoint are merged, and what the crystallization side effect entails, so a 3-parameter synthesis tool is only adequately covered.

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

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

Schema description coverage is 100%, so 'n', 'session_id' and 'crystallize' are already documented in the schema. The description only loosely maps its phrases ('typed session-log turns', 'latest checkpoint', 'codex crystallization') onto those parameters and adds no format or default details beyond them.

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 ('Compose a digest') and a specific resource ('typed session-log turns and the latest checkpoint'), which distinguishes it from plain retrieval siblings such as session.recall or session.replay. It does not explicitly name any sibling it replaces, so differentiation is inferred rather than stated.

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 choose this over session.checkpoint, session.replay, session.recall, or memory.aggregate. The agent must guess that a digest is a synthesis step rather than a read, and nothing says when not to call it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds genuine value by describing the returned fields, which compensates for the absence of an output schema, but it says nothing about ordering, pagination beyond the schema default, or scoping (e.g. whether it lists all users' lanes).

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 dense sentence with zero filler, front-loaded on the verb and resource, with the payload fields trailing. Nothing could be removed without losing 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 simple, annotation-covered read tool with no output schema, the field enumeration is the key missing piece and it is supplied. The remaining gap is modest: no statement about ordering, truncation behavior at the limit, or how lanes relate to the checkpoint/continuity 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 both parameters (limit, session_id) are already documented in the schema. The description does not mention the single-lane filter or the result cap at all, so it adds nothing beyond the structured fields — 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 (List) and a specific resource (session lanes), then enumerates the summary fields each lane carries (turn count, timestamp, preview, start-marker, checkpoint presence). This is far more concrete than the bare title, but it never distinguishes this tool from the many sibling list tools (memory.list, galaxy.list, sutra.list) or from session.recall / session.digest.

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 when-to-use guidance, no exclusion, and no named alternative. An agent must infer on its own whether to call this versus session.continuity, session.digest, or session.recall, all of which presumably surface overlapping session data.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds little behavioral context beyond noting optional query and limit; it does not explain ordering, what happens if session_id is omitted, or the return format.

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

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

It is a single front-loaded sentence with no wasted clauses. The parenthetical is slightly redundant with the schema, but overall the definition is appropriately sized.

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-only tool, the purpose is adequately stated. However, with zero required parameters, it is unclear which session is targeted when session_id is omitted, and there is no output schema or description of returned turns to fill that 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 description coverage is 100%, with limit default, query matching semantics, and session_id already documented. The description merely repeats that query and limit are optional, adding no meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb, "Recall," and resource, "interactions and turns within a targeted session." It clearly conveys the retrieval purpose, but does not differentiate this tool from siblings such as session.replay or session.list.

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 "within a targeted session" and the optional query/limit mention, suggesting targeted retrieval rather than listing sessions. However, it gives no explicit guidance on when to use this instead of session.list, session.replay, or memory search 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?

Annotations declare readOnlyHint=false and destructiveHint=false, i.e. a non-destructive write. The description asserts "READ-ONLY: mutations refused," which flatly contradicts that. With 9 parameters and no output schema, the description also fails to say what a successful record returns or what happens on supersedes/resolves conflicts.

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 short and front-loaded with the verb and resource, so size is fine. However, one of only two clauses is a misleading read-only claim that actively harms comprehension rather than earning 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 9-parameter mutation tool with no output schema and conflicting annotations, the description should clarify the write semantics, whether session_id is required in practice, and what supersedes/resolves do on conflict. It instead spends its budget on a claim that contradicts the annotations.

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 (turn_type, qualifier, importance, resolves, supersedes, session_id, track) is already documented at the field level. The description's example list (decision, breakthrough, summary) loosely maps to turn_type but adds no new semantics. 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?

"Record a session turn" gives a specific verb+resource, and the parenthetical examples (decision, breakthrough, summary) hint at content. But the trailing "(READ-ONLY: mutations refused)" directly undercuts the stated purpose, leaving the agent unsure whether this writes or refuses writes. No differentiation from siblings like session.checkpoint, session.digest, or memory.create.

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 record a turn versus using session.checkpoint, session.digest, memory.create, or memory.ingest, all of which sit in the same namespace and plausibly overlap. "For compounding continuity" is a rationale, not a selection rule.

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 establish read-only, idempotent, non-destructive, non-open-world behavior, so the bar is lower. The description adds genuine non-obvious mechanics: progressive mode trims to the token budget and hybrid reserves up to 30% of the budget for high-salience anchors. It does not describe ordering or the shape of returned turns, but that gap is modest given the 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 verb and resource front-loaded, then a compact enumeration of the four modes with their distinguishing mechanics. No filler, and each clause adds information an agent needs for mode 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?

For an 11-parameter, all-optional tool with no output schema, the description covers the one parameter whose semantics genuinely need prose (mode) and leaves the rest to well-documented schema fields. What is missing is any statement of return shape or ordering, which matters for a replay 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 coverage is 100%, so baseline would be 3, but the description meaningfully elaborates the `mode` enum values, explaining that 'selective' keys off min_importance/turn_types and 'progressive'/'hybrid' key off token_budget — semantics the schema only hints at. It leaves since/until, track and include_superseded entirely to 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 and resource ('Replay the chronological trajectory of a session') and defines each of the four modes. It does not, however, distinguish itself from close siblings like session.recall, session.digest or session.continuity, so an agent must infer the boundary.

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 mode descriptions imply which mode suits which need (filtering, recency, budget-constrained), but there is no explicit 'use this when / use X instead' guidance and no mention of when to prefer session.recall or session.digest. 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?

Annotations already declare readOnlyHint=false, destructiveHint=false and idempotentHint=false, so the safety profile is covered. The description adds the 'start or resume' lifecycle notion but does not explain what happens when an existing session is resumed versus newly created, nor what state is persisted — relevant given idempotentHint=false.

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 tight sentence with the action front-loaded and no filler. It is efficient, though its brevity is close to under-specification for a session-lifecycle tool.

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 tool is simple (2 optional params, no output schema), and the description covers the core intent, but it omits how the returned session relates to siblings (session.record, session.recall) and what to do when a session already exists — gaps an agent must guess at.

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 both optional parameters (user, title), so the schema carries parameter meaning. The description mentions neither, and adds no defaults or formatting guidance beyond what is already structured. 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 pair and resource: 'Start or resume an agent session,' plus the benefit ('persistent continuity across tool invocations'). It is clearly distinct from data-oriented siblings like session.replay or session.list, though it doesn't explicitly name a sibling it replaces.

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 persistent continuity across tool invocations' implies the context in which to use it, but there is no explicit when-to-use/when-not guidance and no pointer to alternatives such as session.checkpoint or session.continuity for other lifecycle 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds what the payload covers (dual-mappings, hand seals, bound Action Skeletons) but says nothing about volume, structure, or whether the canon is static; with no output schema this is a modest gap.

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 no filler; the resource is front-loaded and the content enumeration is compact.

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 no-param, no-output-schema read of an unfamiliar corpus, the description should convey what the agent actually receives (static dump? large document? keyed sections?); it enumerates categories in dense jargon without indicating scale or shape. Adequate but leaves a real 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?

Zero parameters and an empty schema, so there is nothing for the description to disambiguate. Baseline 4 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 ('Inspect') and a specific resource (the canonical Sutra canon) plus the four categories of content it exposes. It does not differentiate itself from the many sutra.* siblings (sutra.list, sutra.cast, sutra.compile, sutra.route), and 'canonical ... canon' is somewhat circular, but the purpose is legible.

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 versus sutra.list, sutra.hexagram, sutra.compile, or sutra.route, no prerequisites, and no exclusions. The agent must infer from the names alone which sutra.* tool to pick.

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 states '(READ-ONLY: mutations refused)', but annotations declare readOnlyHint=false, directly contradicting the claim. The description also mentions executing Action Skeleton cycles and transmitting packets, but the read-only contradiction is a serious inconsistency.

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 only two sentences and front-loads the core action, which is structurally sound. However, the dense jargon and contradictory read-only note reduce clarity, and some phrases do not earn their place for an agent trying to invoke the tool correctly.

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 execution tool with no output schema, the description is incomplete: it does not explain side effects, return values, or the interaction between execute, dry_run, and strict. The annotation contradiction further undermines completeness, leaving the agent with insufficient behavioral context.

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

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

Schema description coverage is 100%, so the input schema already documents all 8 parameters in detail. The description adds only marginal meaning, such as 'transmits swarm mudra packet to P2P peer' for the peer parameter, but does not clarify execute vs. dry_run or strict semantics beyond what the schema already says.

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 provides a specific verb+resource ('Evaluate and dispatch a ... Sutra Codon') and explains mechanics like precondition validation and execution. However, the purpose is obscured by heavy jargon ('Kekkai sandbox boundaries', 'Action Skeleton cycles', 'swarm mudra packet') and it does not differentiate from siblings such as sutra.compile or sutra.route.

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, nor on when not to use it. The only conditional cue is the contradictory '(READ-ONLY: mutations refused)' parenthetical, which does not help an agent choose between this and other sutra.* 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?

Annotations already declare idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds a little beyond that by disclosing the mechanism (static Model2Vec embeddings or lexical centroids), which explains why the operation is deterministic and idempotent. It says nothing, though, about failure modes, what a returned 'codon' contains, or whether compilation is cached.

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 no filler, and the verb and output are stated immediately. The density of unexplained jargon slightly reduces effective clarity, 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 tool whose whole purpose is producing an unfamiliar artifact (a 'Sutra codon' / 'Mudra formula') with no output schema, the description should say what the agent receives and how to use it downstream. It leaves the return value and its relation to siblings like sutra.cast entirely 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?

With a single required parameter at 100% schema description coverage, the schema already explains 'query' fully. The description adds nothing about how the query is interpreted, its expected granularity, or examples of well-formed intent, 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?

It has a clear verb ('Compile') and names the input (natural language intent) and the output (a compound Sutra codon and Taoist Mudra formula). However, 'Sutra codon' and 'Taoist Mudra formula' are undefined domain jargon, and the description never distinguishes this from sibling tools such as sutra.cast, sutra.route, sutra.hexagram, or sutra.canon.

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 the other five sutra.* tools or when not to. An agent seeing sutra.compile alongside sutra.cast and sutra.route has no basis in the text for choosing between them.

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 annotations, the description discloses two important boundaries: results only 'describe the supplied metadata' and the tool neither authenticates sources nor enforces native-store sanctuary access. That trust-boundary disclosure is genuinely useful and not derivable from the structured fields. It does not, however, explain the attest digest semantics or confirm the idempotent/no-side-effect profile declared in annotations.

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

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

Two lean sentences, both front-loaded: the operation first, then the trust-boundary caveat. No filler, and nothing repeats 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 six parameters, nested objects, and no output schema, the description should say more about what a resolve result contains (facts/citations) and what attest returns; currently only the schema carries that. The disclaimer sentence is valuable, but the tool's central contract behavior remains under-explained for its 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%, covering mode, attest, proposal, question, assertions, and request_json in more detail than the description does. The description adds no syntax, mutual-exclusivity, or format guidance beyond what the schema already states, so 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 specific verb pair (resolve/verify) and a specific resource ('bounded caller-asserted temporal assertions'), so an agent knows the operation class. However, it gives no hint of how it differs from close siblings such as sutra.canon, sutra.route, or memory.temporal_query, and the title 'Catuṣkoṭi Answer Contract' adds opacity 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 two modes imply when each applies, and the schema clarifies that 'verify' consumes a proposal, but the description itself states no selection criteria between resolve and verify and no when-not/exclusions against the many adjacent sutra.* and memory.* temporal tools. 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?

Annotations declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, so the safety profile is already structured. The description adds nothing about whether 'mutate_line' actually changes persistent state or merely computes a derived hexagram — a meaningful distinction for an I Ching tool — so it leaves a real behavioral ambiguity unaddressed.

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 stating purpose, followed by a compact enumeration of return fields. The field list is dense but earns its place given there is no output schema. No filler or repetition.

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

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

With no output schema, the description usefully enumerates the return payload (King Wen number, binary symbol, trigrams, Wu Xing element, codon, nuclear, complement, reverse, dynamic transformations). Parameters are fully covered by the schema. The remaining gap is the semantics of 'mutate' — computed vs. persisted — 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%, and the schema already documents accepted query forms (name, pinyin, number, Unicode symbol) and the 1-6 line range for mutate_line. The description adds no syntax or format detail beyond that, 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 gives a specific verb ('Inspect or mutate') and a specific resource ('one of the 64 King Wen I Ching Hexagram Macro-Actions'), so the agent knows exactly what object is being operated on. It does not explicitly differentiate from siblings like sutra.list or sutra.cast, 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.