VaultCrux Platform

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

No annotations are present, so the description must convey behavioral traits. It mentions routing behavior and backward compatibility, but fails to disclose what accepting a handoff package actually does (e.g., state changes, side effects, prerequisites). The core operation remains opaque.

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

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

The description is front-loaded with the core purpose, followed by a clear routing directive. It is reasonably concise, though the second paragraph is a bit long and could be tightened without losing essential guidance.

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 1-parameter tool with no output schema, the description gives the essential meaning but omits operational details like consequences of accepting, idempotency, or any post-conditions. It is minimally viable but not fully 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% and the parameter package_id is already fully described in the schema. The description adds no additional meaning or context about the parameter, 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 first sentence 'Accept an incoming handoff package' is a specific verb+resource that clearly states the operation. It distinguishes from siblings like create_handoff_package and other tools by focusing on the acceptance action.

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

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

The description explicitly instructs to prefer cuecrux_session as the first and only direct MCP call, and notes this tool is for backward compatibility. This provides clear when-to-use and when-not-to-use guidance, with an alternative named.

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

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

With no annotations, the description carries the full burden. It only says 'Search' and lists filters, but does not disclose read-only nature, side effects, rate limits, authentication needs, or return behavior. This is a significant gap for a tool that could be invoked directly.

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 first sentence is concise and informative. The second paragraph about cuecrux_session is useful but slightly verbose; it could be trimmed to a single sentence. Overall, it is well-structured and not bloated.

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 has 6 optional parameters and no output schema, so the description should explain return values and behavior. It does not describe what a receipt is, the return format, default ordering, or pagination semantics. The routing context is helpful, but it does not fill the gap left by the missing output schema and 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 the baseline is 3. The description mentions 'time range, outcome, and tool name' filters, which aligns with schema fields but adds no extra meaning beyond what the schema already provides. No additional syntax or format details are given.

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

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

The description states a specific verb ('Search') and resource ('action journal receipts'), and mentions the key filters. However, it does not explicitly distinguish this tool from similar sibling tools like get_journal or query_vault, so it loses a point for sibling differentiation.

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

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

The description gives explicit routing guidance: 'Prefer cuecrux_session as your first and only direct MCP call' and notes this tool is for backward compatibility. This provides clear context on when to use the tool relative to the preferred channel, but it does not compare to alternative query tools or state when not to use 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?

Without annotations, the description discloses key behavioral context: the tool is legacy, routing truth comes from cuecrux_session, and the 'collapsed surface' is intended. It does not detail side effects or auth, but the core behavior is explicit.

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 with no fluff. The routing guidance is directly useful and earns its place, though slightly longer than strictly necessary.

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

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

For a simple annotation tool with no output schema, the description covers purpose, usage, and the routing caveat. It is sufficient for an agent to invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no additional parameter context beyond the schema, so no points above 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 clearly states 'Add an annotation to the current session' with a specific verb and resource. However, it does not explicitly differentiate from similar sibling tools like comment_on_work, so it loses a point.

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 instructs to prefer cuecrux_session as the first and only direct call, and identifies this tool as backward compatibility only. This gives clear when-to-use vs alternatives.

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

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

No annotations are provided, so the description carries full burden. It does not disclose read-only behavior, return shape, or any side effects; only says it lists bundles. This is a significant gap for a no-annotation tool.

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

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

Four of five sentences are devoted to cuecrux_session routing guidance rather than the tool itself. Purpose is front-loaded, but the message is wordy for a simple one-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?

For a simple optional-parameter listing tool, the purpose and limit schema are sufficient. However, no output format is described and the heavy routing guidance distracts from tool-specific completeness. Adequate but not full.

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

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

Schema coverage is 100% and the single limit parameter has a clear description in the schema. The description itself adds no parameter semantics, 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 'List available credit bundles for purchase' with a specific verb and resource. Clearly differentiated from sibling purchase_bundle by focusing on listing rather than purchasing.

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 instructs to prefer cuecrux_session as the first and only direct MCP call, positioning browse_bundles as a backward-compatibility fallback. Names the alternative and clarifies the intended surface.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only states the action without mentioning side effects, reversibility, permissions, or consequences of changing a seat role. This is a significant gap for a mutation tool.

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

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

The description is compact, with a clear first sentence naming the purpose and two sentences of routing guidance. The routing guidance is relevant but slightly verbose; the overall structure is efficient and front-loaded.

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

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

The tool is a simple two-parameter update, and the purpose is clear. However, with no annotations and no output schema, the description should provide more behavioral context (e.g., what happens on success/failure, constraints on role values). The routing guidance consumes space that could have been used for tool-specific details.

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

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

Schema description coverage is 100%, so the schema already documents both seat_id and role. The description adds no extra meaning or context beyond what the schema provides, making the baseline score of 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 clearly states the tool's purpose: 'Change the role assigned to an existing organisation seat.' This is a specific verb+resource combination that distinguishes it from sibling tools like invite_seat and revoke_seat. The action is unambiguous.

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

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

Explicitly instructs to prefer cuecrux_session as the intended surface, and notes this tool remains directly callable for backward compatibility. This names the alternative and provides clear when-to-use guidance, exceeding baseline expectations.

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

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

No annotations are provided, so the description carries the burden. It conveys that the tool posts a comment and leaves context, but does not disclose permissions, side effects, rate limits, or response semantics. This is adequate for a simple write tool but lacks richness.

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

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

The description is front-loaded with the purpose, followed by a necessary routing instruction. The routing paragraph is somewhat verbose but earns its place by setting usage expectations.

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 write tool with no output schema and no annotations, the description covers what the tool does and how to use it via cuecrux_session, but omits details about return values, error cases, and the author_passport requirement. It is minimally complete but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly explains work_id and body ('comment on a work item'), but author_passport is left unexplained, requiring the agent to infer its purpose from the name or other tools.

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

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

The first sentence, 'Post a comment on a work item — leave context for the next agent or human,' uses a specific verb and resource, clearly distinguishing this tool from siblings like create_work or update_work_state.

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

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

The description explicitly instructs to prefer cuecrux_session as the primary MCP call and states that this tool remains directly callable only for backward compatibility. This provides clear when-to-use and when-not-to-use guidance relative to an alternative.

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

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

With no annotations provided, the description carries full behavioral burden. It only states the purpose and routing preference, but fails to disclose side effects, cost implications, or what happens when a coalition is created. The routing information pertains to another tool, not to the operational behavior of create_coalition itself.

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 divided into a clear purpose sentence followed by a routing paragraph. While the routing instructions are useful, they are somewhat redundant (e.g., 'one call per session is enough' and 'source of routing truth') and could be tightened. The overall structure is logical but not minimal.

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 creation tool with financial parameters (budget_cap, initial_pledge) and no output schema, yet the description doesn't explain expected outcomes, return values, or side effects. It only conveys the tool's purpose and routing guidance, leaving significant gaps for an agent to safely invoke 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 the description can rely on the schema. While the description does not add any parameter-level detail, it also doesn't create confusion. The baseline 3 is appropriate given the schema fully documents 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?

The first sentence 'Create a multi-agent coalition to address a knowledge gap' clearly states the tool's action and object, distinguishing it from sibling tools like join_coalition. The verb 'create' is specific and unambiguous.

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

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

The description explicitly instructs agents to prefer cuecrux_session as the primary routing call, stating 'Prefer cuecrux_session as your first and only direct MCP call' and noting this tool 'remains directly callable for backward compatibility.' This provides clear when-to-use and when-not-to-use guidance, naming the alternative.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It identifies the action as 'create' (implying mutation) but does not explain what a handoff package does, whether it has side effects on the session, what it returns, or any preconditions. The routing instructions are about the broader workflow, not the behavior of this tool. This is a significant gap for a mutation tool.

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

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

The description is well-structured: a one-sentence purpose followed by a focused routing paragraph. While the routing content is valuable, it is somewhat verbose (e.g., repeating that the plan is the 'source of routing truth'). Still, it remains readable and front-loads the purpose. Slightly more brevity would push it to 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?

The tool has a nested object parameter, no output schema, and no annotations. The description explains when to route through `cuecrux_session` but does not explain what the handoff package contains, what a direct call returns, or any side effects. For a tool that may be called directly for backward compatibility, the missing behavioral and output details make it incomplete for an agent needing to invoke it safely and effectively.

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

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

The input schema has 100% description coverage: both parameters (`scope` and `session_id`) are already described. The description adds no additional meaning or usage hints beyond the schema, so the baseline score of 3 is appropriate. No extra context is provided to help with parameter edge cases or relationships.

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

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

The description clearly states the tool's purpose: 'Create a handoff package for multi-agent session transfer.' It uses a specific verb (create) and resource (handoff package), and the name distinguishes it from the sibling tool 'accept_handoff_package' (opposite action). The routing commentary does not obscure this primary purpose.

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

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

The description explicitly tells the agent to prefer `cuecrux_session` as the primary call and states that this tool is for backward compatibility. This clearly answers 'when to use this vs alternatives' and even prescribes the intended call pattern (one session plan call, then rely on the plan). This is exemplary usage guidance.

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

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

No annotations exist, so the description must carry the burden. It states creation and default state but does not disclose side effects, permissions, or what happens after creation; 'collapsed surface' is 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?

The description leads with the core purpose and follows with explicit routing guidance. While the routing explanation is somewhat verbose, each sentence conveys necessary usage context.

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

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

Despite clear purpose and usage, the tool has nine parameters, no output schema, and no annotations, and the description provides no parameter semantics or return behavior. It is not fully adequate for a creation 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?

With 0% schema description coverage, the description only adds the state default, leaving the other eight parameters (linked_pr, assignee_passport, etc.) unexplained. This does not compensate for the schema gap.

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

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

The description uses a specific verb ('Create') and resource ('work item under a project'), and clarifies the default state. It clearly distinguishes from siblings like update_work_state by indicating creation rather than state mutation.

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

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

Explicitly instructs agents to prefer cuecrux_session and use this tool only for backward compatibility, naming the alternative and providing routing rationale. This is strong when-to-use 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?

With no annotations, the description carries full burden and excels: it discloses identical behavior across environments, feature-flagged plan shapes, channel selection for bulk vs MCP-only agents, and the RCX-Protocol version. This goes far beyond a minimal description.

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?

Five concise sentences, each serving a distinct purpose: purpose, usage directive, environment parity, transport behavior, and protocol. No fluff or repetition, front-loaded with the essential purpose.

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 complex session-init tool with no output schema. The description explains the plan's categories (retrieval, proofing, memory, journaling, audit) and its role as routing truth, but does not outline the plan's concrete structure or fields. Still, it provides sufficient operational guidance for the agent to use the returned plan effectively.

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 detailed documentation for every parameter, nested property, and enum mapping instructions. The description itself adds no parameter-specific information beyond what the schema already provides, matching the baseline for complete 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 uses a specific verb ('Opens') and resource ('CueCrux session') and clearly states the output ('typed capability plan'). It also distinguishes itself from siblings by instructing the agent to use this tool first and not to browse the legacy per-service tool list when a plan channel covers the capability.

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 'Call this first, once' and gives a when-not-to-use directive: 'do not browse the legacy per-service tool list when a plan channel already covers the capability.' It also mentions local vs hosted behavior, providing clear context for when this tool applies.

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

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

No annotations are provided, so the description carries the full disclosure burden. It only mentions that the tool declares willingness and aids roadmap prioritization, but omits side effects, persistence, reversibility, permissions, or response details. For a declaration action, this lack of behavioral context is a significant 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?

The description is front-loaded with the core purpose and then provides routing context. It is concise, but the cuecrux_session paragraph includes some redundant phrasing ('One call per session is enough' is already implied). Overall, it is appropriately sized and well-structured.

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

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

With 7 optional parameters, no output schema, and no annotations, the description should provide more context about expected outcomes, return values, and any side effects. It covers purpose and usage but leaves the agent uninformed about what happens when the tool is invoked, making it incomplete for a tool of this complexity.

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

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

Schema description coverage is 100% with detailed descriptions for all 7 parameters, including enums for confidence, billing_cycle, and willingness_band. The description adds no parameter-specific information, so the baseline of 3 applies; it neither enhances nor detracts from 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 'Declare willingness to pay for a feature or category, helping prioritize the product roadmap,' which clearly identifies the verb (declare), resource (willingness to pay), and purpose. It does not explicitly differentiate from sibling tools like submit_feature_request or vote_feature_request, but the tool name and description make the function distinct.

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

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

The description explicitly advises preferring `cuecrux_session` as the 'first and only direct MCP call' and notes that this tool 'remains directly callable for backward compatibility.' This provides clear when-to-use guidance, a named alternative, and an explicit exclusion, satisfying the highest bar.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, what permissions are required, whether any side effects occur, or what the output looks like beyond 'highlight differences.'

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 purpose is front-loaded in one clear sentence, but the second paragraph contains a lengthy meta-instruction about cuecrux_session that is generic platform guidance rather than tool-specific behavior. It is not maximally concise, though the structure is logical and readable.

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

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

With no output schema and no annotations, the description should explain the return value or result format. 'Highlight differences' is vague and does not clarify the structure, while the routing note adds context but not completion. Overall it is adequate for a simple comparison tool but leaves gaps around output and operational behavior.

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

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

Schema coverage is 100% with simple parameters (receipt_id_a, receipt_id_b), and the schema already describes each as 'First receipt ID' and 'Second receipt ID.' The description's 'two provenance receipts' reinforces this but adds no new format or syntax detail 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 first sentence, 'Compare two provenance receipts and highlight differences,' uses a specific verb and resource, clearly stating the tool's function. It distinguishes this tool from siblings like get_proof_receipt by emphasizing the comparison/diff behavior.

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

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

The description provides explicit routing guidance: prefer cuecrux_session as the first and only direct MCP call, use the returned plan for all subsequent work, and treat this tool as directly callable only for backward compatibility. This clearly explains when and how to access the tool, though it does not name functional alternatives like get_proof_receipt.

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

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

With no annotations, the description must disclose behavioral traits, but it provides none about the tool's operation. It doesn't state that the tool is read-only, what output format to expect, or what happens when no answer_id is provided (defaults to last answer is only in schema). The only behavioral hint is that it's legacy/backward-compatible, which is insufficient.

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 contains a long paragraph about cuecrux_session that is not specific to this tool, consuming most of the text. While the first sentence is concise, the routing instructions are verbose and could be condensed into a single line. The structure buries the tool's direct behavior under meta-routing details.

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?

Despite a simple schema, the description lacks important context such as the nature of the explanation output, any side effects, and how 'derived' is defined. Since there is no output schema and no annotations, the description carries more burden and fails to complete the picture for an agent.

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

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

The schema already documents the sole optional parameter (answer_id) with a description including the default behavior. The tool description adds no additional parameter semantics, so the baseline of 3 for high 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 opening sentence clearly states the tool's function: explaining how the last answer was derived. While the rest of the description focuses on routing, the core purpose is unambiguous and distinct from the listed siblings.

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

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

The description gives explicit guidance to prefer cuecrux_session over direct calls, stating it 'remains directly callable for backward compatibility'. This clearly communicates when to use the tool (fallback) and when to use the alternative, which is strong usage guidance.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It only mentions scanning and routing but does not reveal whether the operation is read-only, what side effects exist, any permission requirements, or what constitutes a contradiction. The absence of any behavioral detail beyond the basic purpose makes this insufficient.

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

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

The description is front-loaded with a clear one-sentence purpose, but the routing paragraph is verbose and redundant, repeating the same message in multiple ways ('first and only', 'one call per session', 'source of routing truth'). The content is useful but could be condensed to a single sentence without losing meaning.

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 has no output schema and only two optional parameters, so the description must explain what a 'contradiction' is, what 'knowledge sources' refers to, and the expected return value. The description focuses almost entirely on routing advice and omits these crucial details, leaving the agent unclear about the tool's actual behavior and output.

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

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

The input schema already provides full descriptions for both parameters (depth and scope), giving 100% schema coverage. The description does not add any extra meaning, examples, or format details beyond what the schema supplies. It meets the baseline but adds no 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 clearly states the tool's function with a specific verb and resource: 'Scan for contradictions across knowledge sources.' It is understandable and unambiguous, though it does not explicitly distinguish itself from sibling tools. The purpose is clear but lacks explicit differentiation, which aligns with a 4.

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

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

The description provides explicit usage guidance, instructing to prefer cuecrux_session for routing and clarifying that this tool remains directly callable only for backward compatibility. It names a specific alternative (cuecrux_session) and explains the intended usage pattern, satisfying the when/when-not/alternatives criterion.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions that the tool is a backward-compatible fallback ('remains directly callable for backward compatibility'), but does not describe side effects, read/write behavior, data usage, or return format. For a tool with no annotated safety profile, this is a significant 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?

The purpose is front-loaded in a single clear sentence, which is good. However, the subsequent routing guidance is verbose, with four sentences repeating similar information about cuecrux_session ('returns a typed capability plan', 'one call per session', 'source of routing truth', 'collapsed surface'). This could be condensed into one or two sentences without losing meaning.

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 has no output schema and no annotations, so the description should compensate by explaining what the tool returns or what 'forecast' produces. It does not describe the output format, any prerequisites, or handling of the optional parameters. The routing guidance is useful but leaves the tool's operational behavior underspecified.

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

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

The input schema covers 100% of the parameters: 'domain' and 'artefacts' each have descriptive text in the schema. The description text adds no parameter information beyond the schema, so the baseline of 3 applies per the rubric. There is no additional nuance or constraint provided.

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 first sentence clearly states the tool's function: 'Forecast which artefacts are likely to become obsolete.' This uses a specific verb (forecast), a specific resource (artefacts), and the intended outcome (obsolescence), distinguishing it from sibling tools like get_blast_radius or get_break_analysis. The purpose is unambiguous.

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

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

The description explicitly instructs the agent to prefer `cuecrux_session` over this tool, stating 'Prefer `cuecrux_session` as your first and only direct MCP call' and notes that this tool 'remains directly callable for backward compatibility.' It provides clear when-to-use guidance and names the alternative, making the routing decision straightforward.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Get the currently active policy' and offers legacy/collapsed-surface context, but does not disclose what the tool returns, whether it has side effects, or how the optional parameter affects behavior. The 'backward compatibility' hint is the only extra context, but it is not about the tool's operational behavior.

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

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

The description is concise and front-loaded with the core purpose in the first sentence. The subsequent guidance about cuecrux_session is directly relevant and earns its place, making every sentence carry meaningful information. No wasted words.

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

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

The tool is simple with one optional parameter and no output schema, so the bar is low. However, the description focuses heavily on routing guidance rather than on this tool's own operation, and it fails to explain what an 'active policy' is or how the optional parameter works. The guidance about cuecrux_session provides some context but not enough for the tool's own use.

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?

Although schema coverage is 100%, the description entirely ignores the policy_name parameter. More importantly, the description says 'currently active policy' while the schema says 'Policy name to retrieve,' creating confusion about whether the tool retrieves the active policy or any named policy. The description adds no value beyond the schema and even introduces ambiguity.

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

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

The description opens with 'Get the currently active policy,' which clearly states the verb and resource. It distinguishes from sibling set_policy by implying a read operation. However, it does not explain how the optional policy_name parameter relates to 'active,' leaving ambiguity about whether it retrieves a specific named policy or always the active one.

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

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

The description explicitly instructs to prefer cuecrux_session as the first and only direct MCP call, stating it returns a routing plan that covers this tool. It further clarifies that this tool remains directly callable for backward compatibility and that the collapsed surface is intended, giving clear when-to-use and alternative guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that the tool is a backward-compatible direct call and that the session plan routes it, but it does not disclose whether the operation is read-only, what side effects occur, or what the return format is. For a 'get' tool this is a significant 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?

The first sentence is concise and front-loaded, but the routing paragraph is somewhat redundant ('One call per session is enough' and 'the plan is the source of routing truth' say the same thing) and introduces jargon like 'collapsed surface.' It could be tightened without losing meaning.

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

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

For a simple read tool with fully documented parameters, the description provides enough to decide to use the tool, and the routing context is useful. However, it lacks any mention of the return structure or content of a 'belief,' and with no output schema the agent is left to infer what the response contains. This makes the description adequate but not complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema; it only says 'optional filters' without explaining how filters combine, pagination behavior, or the meaning of 'registered.' The schema itself already documents each parameter adequately.

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

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

The description opens with 'List registered beliefs with optional filters,' which clearly specifies the action (list), resource (registered beliefs), and optional filters. It does not explicitly distinguish this from sibling tools like get_knowledge_gaps or find_contradictions, so it stops short of full differentiation.

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

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

The description explicitly tells the agent to prefer cuecrux_session as the first and only direct MCP call, explains that this tool is routed through that session plan, and states that this tool remains directly callable only for backward compatibility. This provides clear when/when-not guidance and names the alternative.

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

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

No annotations are provided, so the description carries the full burden. It only mentions the estimation function and backward compatibility, without disclosing output format, how the optional parameters interact, or any side effects. This is a significant gap for a tool with zero annotation support.

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 first sentence is concise and effective, but the second paragraph about cuecrux_session is lengthy and somewhat tangential, repeating routing guidance that could be condensed. It is not maximally 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?

With 3 optional parameters, no output schema, and no annotations, the description provides a clear purpose and usage directive but lacks detail on parameter behavior, result shape, and edge cases. It is adequate but leaves room for improvement.

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 each parameter having a description, so the baseline is 3. The tool description adds no extra parameter meaning beyond what the schema already provides.

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

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

The first sentence 'Estimate the impact radius if an artefact or receipt changes' uses a specific verb-resource pair and clearly states the tool's unique function, distinguishing it from siblings like get_break_analysis or get_counterfactual_summary. Despite the later focus on cuecrux_session, the core purpose is unmistakable.

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

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

The description explicitly instructs to prefer cuecrux_session as the primary MCP call and notes that this tool remains directly callable for backward compatibility, with the 'collapsed surface' being the intended surface. This provides clear when-to-use guidance and names an alternative.

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

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

With no annotations, the description must carry the burden of behavioral disclosure, but it only says 'Analyze what would break,' which implies a read-only operation without stating it. It adds the note about backward compatibility but does not disclose side effects, return format, or any operational constraints.

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

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

The first sentence is a concise purpose statement. The second paragraph about cuecrux_session routing is relevant guidance but somewhat lengthy; however, it is front-loaded after the purpose, and every sentence contributes to the decision to use the 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 has no output schema and the description does not explain what the analysis returns, how the parameters interact, or when to invoke this tool directly beyond backward compatibility. The routing instruction is helpful but does not fill the gap in explaining the tool's own behavior and output.

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

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

The input schema describes all three parameters (domain, answer_id, receipt_id) with 100% coverage, so the baseline is 3. The description itself adds no extra meaning about parameters, only implying that 'answer or receipt' maps to answer_id/receipt_id.

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

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

The description opens with a clear, specific statement: 'Analyze what would break if a given answer or receipt is invalidated.' This identifies the verb ('analyze') and the resource (impact of invalidation) precisely. However, it does not differentiate from sibling tools like get_blast_radius, so it misses the top score.

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

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

The description provides explicit routing guidance: 'Prefer cuecrux_session as your first and only direct MCP call' and states this tool is 'directly callable for backward compatibility.' This gives clear when-not-to-use instructions and names an alternative, satisfying the highest bar.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that the tool 'generates' a summary, giving no indication of side effects, read-only nature, permissions, or output behavior. The routing meta-guidance does not illuminate the tool's own behavior, leaving safety and expectations largely unknown.

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

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

The first sentence is concise and front-loaded, but the following routing paragraph is verbose and repetitive, emphasizing cuecrux_session rather than this tool. Statements like 'the plan is the source of routing truth' and 'the collapsed surface is the intended surface' add little distinct value and could be condensed into a single line.

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

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

Given no annotations, no output schema, and ambiguous parameter requirements, the description is insufficient. It does not clarify what a counterfactual summary is, whether answer_id, receipt_id, or both are needed, what the return format is, or whether direct use is discouraged due to deprecation. The routing guidance does not compensate for these gaps.

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

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

The input schema already provides 100% description coverage for the two parameters (answer_id and receipt_id), so the baseline is 3. The description does not add meaningful parameter context and introduces potential ambiguity by saying 'for an answer' while the schema includes a receipt_id, without explaining the relationship or optionality between the two fields.

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

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

The description opens with 'Generate a counterfactual summary for an answer', which is a specific verb+resource statement that clearly identifies the tool's core function. However, it does not distinguish itself from sibling tools like explain_last_answer or find_contradictions, and the subsequent routing guidance about cuecrux_session somewhat clouds the tool's standalone purpose.

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

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

The description provides explicit guidance to prefer cuecrux_session as the routing entry point and states that this tool remains directly callable only for backward compatibility. This clearly communicates when-not-to-use the tool in favor of an alternative. However, it does not explain when direct use might be appropriate or how this tool compares to other summary-related siblings.

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

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

With no annotations provided, the description carries the full burden. It discloses the tool's legacy status and the preference for cuecrux_session, which is useful behavioral context. It also mentions 'receipt verification and passport data' but does not explain what these entail or whether any side effects or authorization are required. The description adds some value but leaves significant ambiguity about the tool's 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?

The first sentence is concise and front-loaded with the primary purpose. The second paragraph, while informative, is somewhat verbose and repeats the idea of preferring cuecrux_session multiple times. It could be tightened without losing meaning, but overall the structure is clear and the length is justified by the important routing guidance.

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

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

The description covers the core action and provides routing context, but lacks detail on the output structure. Since there is no output schema, the description should explain what 'receipt verification' and 'passport data' mean in terms of the returned data. It also does not mention any preconditions or side effects, leaving some gaps for a simple getter tool. The legacy/backward-compat context is helpful, but the description is not fully 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?

The tool has zero parameters, so the schema trivially provides 100% coverage and parameter semantics are not a concern. The description does not need to elaborate on parameters, and it does not mislead. The baseline of 4 applies because there are no parameters to describe.

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

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

The description clearly states the tool retrieves the current credit balance for the agent, including receipt verification and passport data. It uses a specific verb and resource, making the core purpose evident. However, it does not explicitly differentiate from siblings like get_credit_escrow or get_passport, though the mention of 'receipt verification and passport data' adds some distinction.

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

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

The description provides explicit guidance: prefer cuecrux_session as the first and only direct MCP call, and this tool remains directly callable only for backward compatibility. It clearly states the intended usage (via the collapsed surface) and when this tool should be used (as a legacy fallback), effectively distinguishing it from the alternative.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'List active escrow holds,' which implies read-only behavior but does not explicitly state safety, auth requirements, rate limits, or return format. The routing meta-instruction does not substitute for behavioral transparency.

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

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

The first sentence is appropriately front-loaded and concise, but the description then includes a multi-sentence routing block that is tangential to the tool itself. While useful, the routing guidance makes the description wordier than necessary for a simple parameterless read operation.

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 parameterless tool with no output schema, the description adequately states its purpose and adds important context about the recommended routing path via cuecrux_session. It does not describe the return value format, but given the simplicity of the operation, this is not a significant 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 has zero parameters, and the schema covers them vacuously (100% schema description coverage). The description does not need to elaborate on parameters, so the baseline score of 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 description clearly states 'List active escrow holds for the tenant,' providing a specific verb, resource, and scope. It is distinct from sibling tools like get_credit_balance, and the routing instructions do not obscure the core purpose.

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

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

The description explicitly instructs agents to prefer cuecrux_session as the primary entry point, explaining that it returns a capability plan and routes all subsequent calls. It also clarifies that this tool remains directly callable for backward compatibility, offering clear when-to-use 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?

With no annotations, the description carries full burden for behavioral disclosure. It only says 'get' and mentions backward compatibility, but reveals no details about side effects, output, costs, or rate limits. The behavioral traits are largely unknown.

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

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

The description is front-loaded with the purpose, and the remaining sentences about routing are relevant. It is slightly verbose, but each sentence contributes to usage guidance, so it is reasonably concise for its purpose.

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 (no params, no output schema), but the description still lacks information about what the daily briefing contains or what the return value looks like. The routing context is helpful, but direct callers are left without enough detail about the tool's output.

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

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

The tool has zero parameters, so the schema coverage is trivially 100%. Per the baseline for 0 params, a score of 4 is appropriate; the description does not need to add 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 tool's function with 'Get the daily knowledge briefing' – a specific verb and resource. It also distinguishes itself from the sibling tool `cuecrux_session` by indicating the latter is preferred, though it doesn't elaborate on what the briefing contains.

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

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

The description explicitly instructs to prefer `cuecrux_session` first and only call this tool for backward compatibility. It provides clear when-to-use and when-not-to-use guidance, and names the alternative tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the tool is a backward-compatibility surface but fails to state whether it is read-only, what its output looks like, or whether it has side effects or costs. The routing guidance is about a different tool, not this tool's own behavior.

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

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

The description is front-loaded with the purpose and then provides essential routing context. The paragraph about cuecrux_session is somewhat lengthy relative to the tool's simplicity, but it is actionable and earns its place by guiding the agent toward the intended surface.

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

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

With no output schema and no annotations, the description should explain what domain affinity scores are and what the tool returns. It does not, leaving a significant gap in the agent's ability to interpret the result.

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

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

The tool has zero parameters, so the schema fully documents the interface with 100% coverage. The description adds no parameter details, but none are needed; the baseline of 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 description clearly states the tool retrieves the agent's domain affinity scores, with a specific verb and resource. It does not explicitly differentiate from sibling getter tools like get_beliefs or get_reasoning_profile, but the resource is distinct enough.

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

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

The description explicitly instructs agents to prefer cuecrux_session as the first and only direct MCP call, explaining that it routes this tool and others to preferred channels. It also clarifies that this tool remains directly callable only for backward compatibility, providing strong when-to-use and when-not-to-use 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?

With no annotations, the description must carry the burden of explaining behavior. It discloses that the tool retrieves a dashboard with specific content and that direct invocation is a backward-compatibility fallback behind the preferred cuecrux_session routing plan. However, it does not mention access requirements, potential staleness, or error conditions.

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 first sentence efficiently states the purpose. The second paragraph explains the routing preference, though it is slightly verbose with repeated emphasis ('first and only direct MCP call', 'one call per session is enough'). Still, it is well-structured and front-loaded.

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

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

Given no output schema and no parameters, the description adequately specifies what the dashboard returns and provides essential routing context. It could be more explicit about the exact structure or pagination, but it is complete enough for an agent to use the tool.

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

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

The tool has zero parameters, so the baseline is 4. The description appropriately explains what the dashboard shows (balances, transactions, summaries), which is sufficient for understanding the tool's function without parameter details.

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

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

The description opens with a specific verb and resource: 'Retrieve the economy dashboard for the agent,' and then lists the content (balances, recent transactions, spending summaries). This clearly distinguishes it from sibling tools like get_credit_balance or get_spend_receipt.

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

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

The description explicitly instructs to prefer `cuecrux_session` as the first and only direct MCP call and states that this tool remains directly callable for backward compatibility. This provides clear when-to-use and when-not-to-use guidance, effectively routing agent behavior to the session-based plan.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the list action and optional filters, omitting important details such as pagination via the cursor parameter, response format, ordering, and the read-only nature. The cuecrux_session routing note is generic and does not describe this tool's runtime behavior.

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

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

The purpose is front-loaded in a single clear sentence, but over half the description consists of a generic cuecrux_session routing paragraph that is not specific to this tool and adds noise. While the structure is logical, the description is not as concise as it could be for this 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 no output schema and no annotations, the agent is left without information about the return shape, pagination behavior, or other invocation details. The routing note does not help with correct usage of this specific tool. The first sentence gives a basic idea, but the description is incomplete for a tool with a cursor parameter and potential pagination.

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

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

The input schema already documents all four parameters (limit, cursor, status, category) with descriptions, so the tool description adds minimal semantic value. The phrase 'optional filtering by category and status' restates what the schema implies. Since schema coverage is 100%, a baseline score of 3 is appropriate.

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

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

The description opens with a clear verb and resource: 'List feature requests'. It further specifies optional filtering by 'category and status', and the 'list' action naturally distinguishes it from sibling tools like submit_feature_request and vote_feature_request, which are write operations.

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 first sentence implies the tool is for listing feature requests. The routing note explicitly directs the agent to prefer cuecrux_session for a routing plan, with this tool remaining directly callable for backward compatibility, giving a clear call hierarchy. However, it does not name a direct alternative for listing feature requests beyond the generic session 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?

With no annotations, the description carries the full burden for behavioral disclosure. It only states the fetch action and does not mention read-only nature, permissions, rate limits, return format, or side effects. This is a significant gap for a tool that could have hidden costs or auth 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?

The tool purpose is front-loaded in a single sentence. The second paragraph provides valuable routing guidance, but it is verbose and could be condensed. Every sentence earns its place, but it lacks the crispness of a truly concise description.

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 a simple fetch with full schema coverage, so basic invocation is clear. However, there is no mention of return value format, error conditions, or any usage caveats. The routing paragraph gives session-level context, but the tool-specific description is not fully 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% for all four parameters, each with descriptions. The description adds grouping context (time range, entry type, pagination) but does not add meaningful detail beyond what the schema already provides, so a 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 first sentence clearly states the tool fetches journal entries for the active agent and mentions filtering options. The resource and verb are specific, though it does not explicitly differentiate from the sibling action_journal_query.

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

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

The description explicitly instructs agents to prefer cuecrux_session as the first and only direct call, and states that this tool is for backward compatibility. This is a clear when/when-not usage guideline with a named alternative.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, what the return format looks like, or any side effects. The only behavioral trait mentioned is that the tool is a legacy fallback, which is more about routing than runtime behavior. This is a significant transparency 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?

The description front-loads the purpose in one short sentence, then adds a placement paragraph about routing. While the routing instructions are verbose relative to the purpose statement, they are goal-directed and add necessary context. The structure is clear and easy to scan, but the routing paragraph could be tightened.

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 a simple read-style operation with 3 parameters and no output schema. The description provides clear routing context but lacks details about the returned data, pagination behavior, or when this tool is actually necessary despite the backward-compatibility note. Enough for a basic understanding, but missing behavioral details that would make it fully self-contained.

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 all three parameters (limit, domain, offset), so the schema already fully documents the parameter semantics. The description does not add any extra meaning or usage context for the parameters, meriting the baseline score of 3.

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

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

The description clearly states the tool's function: 'Identify knowledge gaps across domains.' It uses a specific verb and resource, and it distinguishes itself from the preferred alternative (cuecrux_session) by noting it is a backward-compatibility fallback. However, the heavy emphasis on not using the tool directly slightly muddies the core purpose, so it doesn't earn a 5.

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

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

The description provides explicit routing guidance: 'Prefer cuecrux_session as your first and only direct MCP call... This tool remains directly callable for backward compatibility; the collapsed surface is the intended surface.' This tells the agent exactly when to use this tool versus the alternative, making usage guidance exceptionally clear.

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

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

No annotations are present, and the description relies on 'Retrieve' to imply a read-only operation. It adds the legacy/routing context but does not disclose the response shape, possible errors, caching, or any side effects, leaving behavioral transparency limited.

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 the main purpose, and the routing guidance is useful. It is slightly repetitive around 'one call per session' and 'collapsed surface is the intended surface', but it remains efficient.

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

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

For a zero-parameter getter with no output schema, the description covers purpose and routing, but it does not explain what a trust passport contains or what the caller receives. The missing return-value context weakens completeness, though the legacy-status guidance is valuable.

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

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

The input schema has zero parameters, so the description has no parameter details to add. The baseline for no-parameter tools is 4; the description appropriately contains no parameter chatter.

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

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

The description opens with a specific action and object: 'Retrieve the agent's trust passport.' It also distinguishes this tool from the collapsed surface by stating that cuecrux_session should route it, clarifying that direct invocation is a backward-compatibility path.

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?

Explicit guidance is given: prefer cuecrux_session as the first/only direct call, and use one per session; get_passport remains directly callable only for backward compatibility. This clearly states when to use and when not to use the tool.

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

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

With no annotations, the description carries the full burden. It does not explicitly state safety (e.g., read-only) or return format, but it does disclose a behavioral trait: direct calls are for backward compatibility and the collapsed surface is intended. This adds some context beyond the basic retrieve action, but leaves out details about side effects or cost implications.

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

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

The description is concise, with two sentences: the first states purpose, the second explains routing context. The routing advice is long but not wasteful given the explicit guidance. It is well structured and front-loaded, though the routing paragraph could arguably be shortened without losing meaning.

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 parameterless getter with no output schema, the description covers all essential context: what it does, how it relates to cuecrux_session, and the backward-compatibility status. It explains the intended usage pattern and why direct calls are allowed. No return format is needed as 'pricing information' is self-explanatory.

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

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

The input schema has zero parameters and 100% schema coverage, so there is no parameter information to add. The description implicitly scopes the request to 'the tenant' (likely the current session tenant), which is a mild semantic addition. The baseline of 4 applies because no parameters exist and the description need not compensate.

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

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

The description opens with a specific verb and resource: 'Retrieve current pricing information for the tenant.' This clearly states the tool's function and distinguishes it from sibling get_* tools by focusing on pricing. It also differentiates from cuecrux_session by positioning that as a routing plan, making the purpose of get_pricing explicit.

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

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

The description gives explicit usage guidance: prefer cuecrux_session as the first and only direct MCP call, use one call per session, and treat the plan as the routing truth. It also clearly states that get_pricing remains directly callable only for backward compatibility, effectively telling the agent when to use and when not to use this tool.

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

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

No annotations are provided, so the description bears the transparency burden. It discloses that the tool is legacy/backward-compatible and lists its content scope, but does not explicitly state whether it is read-only, any authentication needs, rate limits, or other side effects. The word 'Detail' implies read-only, but the description lacks a robust behavioral profile.

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

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

The description is two sentences: the first states the tool's purpose with specific details, and the second provides routing guidance. It is front-loaded, compact, and every sentence earns its place without redundancy.

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

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

For a simple getter with one parameter, the description conveys what the tool returns (planning target, allowed passports, working tenants) and the important legacy/routing caveat. It lacks an explicit return format, and no output schema exists, so the description carries some burden. Overall, it is mostly complete but could be slightly more explicit about response 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?

Schema coverage is 0% and the description does not directly explain the 'project_id' parameter. However, the tool name and phrase 'single project' make the parameter inferable. With only one self-explanatory parameter, the description offers marginal added meaning but does not fully compensate for the lack of schema documentation.

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

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

The description opens with 'Detail for a single project' followed by specific content fields ('planning target, allowed passports, working tenants'), giving a clear verb+resource+scope. It distinguishes itself from siblings by focusing on a single project's context, and the explicit mention of the alternative cuecrux_session further clarifies its place.

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 explicit guidance: 'Prefer cuecrux_session as your first and only direct MCP call' and explains why, then notes this tool remains 'directly callable for backward compatibility'. This clearly states when to use this tool versus the alternative and the intended 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?

With no annotations provided, the description carries the disclosure burden. It adds useful behavioral details: the prerequisite of a 'completed proof job' and support for 'cursor-based pagination.' These go beyond the schema and help the agent anticipate constraints and behavior.

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

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

The first sentence is concise and informative. The second paragraph, while valuable, is somewhat verbose and shifts focus to cuecrux_session routing. It could be tightened, but overall the structure is clear and not bloated.

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 retrieval tool with only two parameters and no output schema, the description covers the essential aspects: what it retrieves, the prerequisite, and pagination behavior. It does not describe the output format, but given the simplicity, this is not a major gap.

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

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

Schema coverage is 100% with both parameters having descriptions. The tool description does not add new semantic information about the parameters themselves (e.g., format, defaults, or constraints), so the baseline score 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 first sentence clearly identifies the action ('Retrieve') and the resource ('chunk-level hashes for a completed proof job'), which distinguishes it from sibling tools like get_proof_status or get_proof_receipt. The purpose is specific and unambiguous.

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

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

The description explicitly advises preferring `cuecrux_session` as the primary entry point and notes that this tool remains directly callable for backward compatibility. This provides clear when-to-use guidance and names the alternative tool, making it easy for an agent to route correctly.

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

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

With no annotations, the description carries the full burden. It discloses the bundle contents and positions the tool as a legacy surface, implying a read-only download. However, it does not mention permissions, costs, or error conditions. For a simple download operation, the disclosure is adequate.

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 first sentence is concise and informative. The second paragraph is lengthy but provides essential routing guidance that justifies its inclusion. Slight redundancy ('remains directly callable' / 'collapsed surface') keeps it from a 5.

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

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

For a simple one-param tool with no output schema, the description clearly explains what the tool returns (bundle contents) and its intended usage context via cuecrux_session. It omits details like response format or size, but overall it is sufficient for an agent to select and invoke the tool correctly.

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

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

The input schema covers 100% of the parameter with a clear description ('The receipt ID to get the proofpack for'). The tool description adds no additional semantic value beyond restating the purpose, 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 clearly states the tool downloads the full proofpack bundle for a receipt, enumerating contents (chunk hashes, Merkle tree, signature, verification instructions). This distinguishes it from siblings like get_proof_chunks, get_proof_receipt, and get_proof_status.

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

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

The description explicitly instructs to prefer `cuecrux_session` as the routing entry point and notes this tool remains directly callable only for backward compatibility. This provides clear when-to-use and when-not-to-use guidance relative to an alternative.

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

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

With no annotations, the description must convey safety and behavior. 'Retrieve' signals read-only, the first paragraph discloses return contents, and the backward-compatibility note tells agents it is a legacy fallback. It does not detail auth, cost, or failure modes, but it provides more than the bare minimum.

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 first sentence is front-loaded and clear, and the routing paragraph is purposeful but more verbose than necessary—e.g., 'one call per session is enough' and 'source of routing truth' overlap. It is still appropriately sized for the guidance it contains.

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

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

Given a single parameter and no output schema, the description adequately explains the result contents and adds session-routing context. It could mention error cases or relationship to get_proof_status/get_proof_chunks, but it is not incomplete for the tool's complexity.

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

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

The input schema already fully describes answer_id (coverage 100%). The description adds no format, constraints, or examples, so the baseline 3 applies.

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

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

The opening sentence states a specific verb ('Retrieve') and resource ('cryptographic proof receipt') scoped to 'a specific answer,' and the content list (Merkle root, signature, verification metadata) separates it from sibling proof tools like get_proof_status or get_proof_chunks.

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

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

The description explicitly instructs agents to prefer cuecrux_session for routing and states that this tool is only directly callable for backward compatibility, with the collapsed surface intended. This is clear when-to-use vs an alternative, though it does not contrast with specific proof-related siblings.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It discloses that the tool returns state and progress details, and implies a non-mutating read operation through 'poll.' However, it does not explicitly state read-only nature, permissions, or potential side effects, leaving some gaps.

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 first sentence is concise and front-loaded. The second paragraph about cuecrux_session is informative but somewhat verbose, with repetition of the preference for cuecrux_session and routing details. Still, every sentence serves a purpose, so it earns a 4.

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 polling tool with one parameter and no output schema, the description adequately covers purpose, return values, and routing context. It would be more complete if it mentioned error scenarios or response format details, but these are not essential for a read-only status check.

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

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

The input schema has 100% description coverage for the single parameter, specifying 'The proof job ID to check.' The tool description adds no additional parameter semantics beyond this, 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 clearly states the tool's function with a specific verb and resource: 'Poll the status of a proof job. Returns the current state (queued, processing, complete, failed) and progress details.' This distinguishes it from sibling tools like get_proof_receipt or get_proof_chunks by focusing on job status polling.

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

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

The description explicitly instructs agents to 'Prefer cuecrux_session as your first and only direct MCP call' and notes this tool is for backward compatibility, providing clear guidance on when to use this tool versus the preferred alternative. It also clarifies the intended routing surface.

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

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

No annotations are provided, so the description must carry the burden. 'Get' implies read-only, and the routing/backward-compat context adds useful behavioral information. However, it does not disclose return format, failure modes, or any prerequisites like session state, leaving some behavior opaque.

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 purpose is front-loaded in the first sentence, and the guidance is useful. However, the routing advice is somewhat redundant: 'source of routing truth' and 'collapsed surface is the intended surface' repeat the same directive, so it could be tightened.

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 getter with no output schema and no annotations, the description provides solid selection guidance and backward-compatibility context. It does not specify what the reasoning profile contains or the exact return shape, but the routing alternative is clearly and fully described.

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

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

The tool has zero parameters and schema description coverage is 100%, so the baseline is 4. The description correctly avoids inventing parameter details, and no additional parameter semantics are needed.

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

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

The description opens with a specific verb and resource: 'Get the agent's current reasoning profile.' This clearly distinguishes it from siblings like set_reasoning_profile and aligns with the tool name.

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

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

The description explicitly tells the agent to prefer cuecrux_session as the first and only direct MCP call, explains that it routes this tool to a preferred channel, and notes that this tool remains directly callable for backward compatibility. This gives clear when-to-use and alternative 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?

With no annotations, 'Retrieve' strongly implies a read-only operation, and the description adds context about the tool being a backward-compatible fallback. However, it does not explicitly mention side-effect-free behavior, auth needs, or rate limits, though the verb and context make the safety profile reasonably clear.

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

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

The description is two sentences, with the purpose in the first and routing guidance in the second. Every clause contributes meaningful information, including the rationale for preferring cuecrux_session, making it highly concise and directly front-loaded.

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

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

Given the tool's simplicity (0 params, no output schema), the description provides a clear purpose and critical routing guidance. It mentions 'recent interactions and state' to indicate content but does not detail the exact return structure. The guidance to rely on cuecrux_session fills important operational context, so the overall completeness is adequate.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is no parameter information to add. The baseline for zero-parameter tools is 4, and the description appropriately avoids irrelevant parameter details.

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

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

The description clearly states 'Retrieve the current session context for the active agent, including recent interactions and state,' using a specific verb and resource. It also distinguishes itself from siblings by positioning cuecrux_session as the preferred route and this tool as a backward-compatible fallback.

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

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

The description explicitly instructs 'Prefer cuecrux_session as your first and only direct MCP call' and explains that this tool remains directly callable for backward compatibility. It provides clear when-to-use and when-not-to-use guidance with a named alternative.

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

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

With no annotations, the description carries the burden for behavioral disclosure. The word 'Retrieve' implies read-only behavior, and 'backward compatibility' indicates this is a legacy path, which adds some context beyond the schema. However, it does not disclose return format, error behavior, or authentication needs, so it is only partially transparent.

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

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

The first sentence is concise and front-loaded. The second paragraph is longer but earns its place by providing routing guidance, though it has some redundancy ('one call per session is enough' and 'plan is the source of routing truth' say overlapping things). Overall it is reasonably sized and structured.

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

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

For a simple one-parameter tool with no output schema, the description covers purpose and usage guidance well. It explains the preferred routing via cuecrux_session and notes backward compatibility. It does not describe the return value explicitly, but given the simple 'get by ID' nature and the title, the description is fairly 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% since receipt_id has a description ('The receipt ID to look up.'). The description's 'by ID' aligns with the parameter but adds no new meaning. Baseline 3 is appropriate because the schema already documents the parameter fully.

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

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

The description opens with 'Retrieve a specific spend receipt by ID,' which is a specific verb+resource construction that clearly states the tool's action and target. The resource 'spend receipt' distinguishes it from siblings like get_proof_receipt and diff_receipts, so purpose is unambiguous.

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

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

The description provides explicit routing guidance: 'Prefer cuecrux_session as your first and only direct MCP call... This tool remains directly callable for backward compatibility.' This tells the agent when to prefer an alternative and when direct use is acceptable, which is exactly the kind of exclusions and alternatives the rubric rewards.

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

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

No annotations are provided, so the description carries the full transparency burden. It only says 'List', which implies a read operation, but does not disclose whether pins are modified, how staleness is determined, auth requirements, or response/pagination behavior.

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

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

The main purpose sentence is concise and front-loaded, but the long CueCrux routing paragraph adds meta-instructional content not specific to this tool. This makes the description less concise than necessary, though still structured with purpose first.

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

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

With no output schema and no annotations, the description should explain what the returned data contains (e.g., pin IDs, staleness reasons) and how pagination works. It only provides a high-level purpose, leaving these operational details 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 input schema already describes both parameters (limit and cursor) with 100% coverage, so the description need not add much. It does not clarify defaults or how the cursor is obtained, but the schema sufficiently covers 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 description opens with a specific verb ('List'), names the resource ('pinned items'), scopes to 'active agent', and qualifies with 'may be outdated and need refresh or removal.' This clearly distinguishes the tool from sibling get_* tools and gives an unambiguous purpose.

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

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

The description explicitly instructs the agent to prefer cuecrux_session as the routing entry point and notes this tool remains directly callable for backward compatibility, providing a clear when-not to call directly. However, it does not offer functional alternatives among the sibling get_* tools.

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

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

No annotations are provided, so the description bears full responsibility. It does not disclose the return format, side effects, permissions, or error conditions. The only behavioral note is about routing via cuecrux_session, which is system-level context rather than this tool's actual behavior. The agent is left to guess what an 'escalation level' is and what happens on direct invocation.

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

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

The description is concise and well-structured. The first sentence front-loads the core purpose, and the subsequent sentences provide essential routing guidance without redundancy. Every sentence earns its place, making it efficient and readable.

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 clarify what the return value is (e.g., type, range, or format). It only says 'trust escalation level,' which is vague. The routing guidance is helpful but does not compensate for the missing return-value detail. The tool is simple, so this is adequate but has clear gaps.

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

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

The tool has zero parameters, and the schema coverage is vacuously 100%. The baseline for 0 parameters is 4, and the description adds no parameter details because none are needed. It correctly omits any param discussion.

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 the specific verb 'Get' with a clear resource: 'the current agent's trust escalation level.' It explicitly names cuecrux_session as the preferred alternative, which distinguishes this tool from the intended routing surface and sibling tools.

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

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

The description provides explicit guidance: prefer cuecrux_session as the first and only direct MCP call, note that it returns a typed capability plan routing all tools, and state this tool is only for backward compatibility. This makes when to use this tool vs. the alternative absolutely clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the retrieve behavior and mentions filtering and pagination, but offers no details on response structure, potential side effects, errors, or rate limits. For a read-only tool, this is adequate but minimal, lacking any deeper behavioral context.

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

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

The purpose is front-loaded in a concise first sentence. However, the second paragraph about cuecrux_session is verbose and introduces jargon like 'collapsed surface' and 'typed capability plan,' which may be confusing. It earns its place for routing context but could be trimmed for brevity.

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, yet the description does not describe the alert return format or the shape of paginated responses. It does provide important routing context about cuecrux_session, which is helpful for correct usage. However, given the lack of annotations and return docs, the description leaves gaps in the agent's ability to fully predict the tool's output.

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%, meaning every parameter (watch_id, since, limit, cursor) already has a description in the schema. The description's phrase 'optional filtering by time and pagination' summarizes the since/limit/cursor parameters but adds no new semantic detail beyond what the schema provides. 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 first sentence clearly states the tool's function: retrieving alerts for a specific watch, with optional filtering by time and pagination. This specific verb+resource structure distinguishes it from siblings like get_watches (which likely lists watches) and get_daily_briefing (daily summary).

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

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

The description explicitly instructs the agent to prefer cuecrux_session as the first direct MCP call, providing a clear routing directive and explaining that the plan returned by cuecrux_session is the source of truth. It also mentions that this tool remains directly callable for backward compatibility. While it doesn't enumerate all alternatives or explicit when-not-to-use scenarios, it gives strong contextual guidance.

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

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

No annotations are provided, so the description carries the burden. It states the tool lists active watches but does not disclose any side effects, return format, or edge cases. It is a read-only operation by implication but lacks explicit behavioral detail.

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 first sentence is concise and informative. The subsequent routing guidance is relevant but somewhat verbose, with some repetition ('the plan is the source of routing truth' and 'the collapsed surface is the intended surface'). Could be tightened but overall well-structured.

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

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

The tool is simple with two self-descriptive parameters and no output schema. The description provides important routing context (cuecrux_session) and clarifies backward compatibility. However, it does not explain what 'watches' are or what the response contains, which could be useful for an agent.

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

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

Schema coverage is 100% with both parameters (limit, cursor) already described in the schema. The description adds no extra semantic context for the parameters, so the baseline score 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 clearly states 'List all active watches for the current agent' with a specific verb and resource. It distinguishes itself from sibling tools like get_watch_alerts by focusing on watches rather than alerts.

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?

Explicit guidance is provided: 'Prefer cuecrux_session as your first and only direct MCP call' and 'This tool remains directly callable for backward compatibility'. This clearly tells when to use the tool versus an alternative.

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

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

There are no annotations provided, so the description must disclose behavior. It does not mention whether this is a read-only operation, what the output format is, how 'selected repos' are determined, or any rate limits/errors. The routing context about cuecrux_session does not describe the tool's own behavior.

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

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

The description is front-loaded with the purpose in the first sentence, followed by two sentences about routing. Each sentence provides some value, though the routing guidance may be redundant if present in other tool descriptions. Overall it is concise and structured.

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

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

The tool is simple (one optional parameter) but the description omits key context: what constitutes 'selected repos', what 'Crux-Indexed' means, what the return value looks like, and how to interpret the results. It also does not differentiate from other github_* tools beyond stating it covers comments.

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

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

The input schema includes a single `limit` parameter with min/max but no description. The description makes no mention of `limit` or any other parameter semantics, so it adds zero value 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 it returns 'Recent comments across selected repos', clearly indicating the resource (comments) and scope (since last looked). This distinguishes it from sibling tools focused on commits (github_recent_commits) and issues (github_open_issues), though the phrase 'selected repos' is vague about which repos are included.

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 explicitly directs the agent to prefer `cuecrux_session` as the first MCP call, which provides a routing plan for all tools. It also notes this tool is directly callable for backward compatibility, giving clear guidance on when to use it versus the preferred entry point.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It mentions 'client-side filtering' for the label parameter, implying that filtering happens locally, but gives no details about pagination, sorting, read-only nature, or what 'indexed' means operationally. The description does not explain the behavior of the `limit` parameter or how the output is structured, leaving significant gaps for a tool with zero annotation support.

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 first sentence is concise and front-loaded with the core purpose. However, the second paragraph about cuecrux_session takes up more than half the description and is meta-contextual rather than directly about this tool. While these routing instructions are arguably useful, they could be moved to session-level guidance, making the tool description less focused. The description is not verbose but includes content that dilutes its immediate applicability.

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

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

Given the tool's simplicity (list issues for a repo), the description provides only the barest outline. It does not mention return format, pagination, whether closed issues are excluded, or how the index affects results. There is no output schema to compensate, and annotations are absent, so the description leaves the agent without enough context to predict the tool's behavior or results. This is a significant gap for a usable tool.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It only explains the `label` parameter as 'for client-side filtering', adding some value. However, it does not describe `repo` (beyond the obvious from the name) or `limit`, leaving these parameters underspecified. With 3 parameters and minimal coverage, the description is insufficient to guide proper usage.

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 'Indexed issues in a selected repo' which clearly indicates the tool retrieves GitHub issues for a given repository. The title 'Open GitHub Issues' further specifies the scope, distinguishing it from sibling tools like github_open_prs (PRs) or github_comments_since (comments). However, the term 'indexed' is slightly ambiguous and could imply a specific backend implementation rather than a simple 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?

The description provides usage guidance by telling the agent to prefer cuecrux_session for routing and to use this tool only for backward compatibility. This is a clear directive on the preferred invocation pattern. However, it does not explicitly compare with direct alternatives like github_open_prs or discuss when to choose this tool over them, leaving the context for selection partially implied.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals that the tool returns indexed PRs and that open-filtering is done client-side, which is a meaningful behavior. However, it does not detail read-only nature, rate limits, or what 'indexed' implies beyond that, so it is partially transparent but not comprehensive.

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 first sentence is succinct and informative. The second paragraph about `cuecrux_session` is longer and somewhat repetitive but serves an important routing purpose. Overall, the structure is acceptable but the routing explanation could be tightened.

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

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

No output schema exists, and the description does not explain the return value beyond mentioning the `state` field. It also omits details about pagination (limit default, max) and any error or authentication context. For a simple tool, this is 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 0%, so the description must compensate for parameter meaning. It only mentions 'selected repo' which aligns with the `repo` parameter, but it provides no explanation for the `limit` parameter or its constraints (1-200). This is a clear gap.

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

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

The description clearly identifies the tool as returning indexed PRs for a selected repo, with a note about filtering open PRs client-side via the `state` field. This distinguishes it from sibling tools like `github_open_issues` and `github_recent_commits`, though the verb 'Indexed' is less explicit than 'List' or 'Get'.

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

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

The description provides explicit guidance to prefer `cuecrux_session` as the primary entry point, stating that it routes this tool (and others) to the preferred channel, tier, and cost class. It also clarifies that this tool remains directly callable only for backward compatibility, giving a clear when-not-to-use directive.

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

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

With no annotations, the description must disclose behavioral traits. It only states the tool lists 'recent indexed commits' without mentioning pagination, return format, authentication, or any side effects. The extensive discussion of cuecrux_session relates to routing, not to this tool's operational behavior.

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

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

The description is relatively short, with the core purpose in the first sentence. However, the second paragraph about cuecrux_session takes up significant space and could be considered tangential to the tool's semantics, but it does provide needed routing context.

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

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

The tool is simple, but the lack of annotations and output schema places more burden on the description. The description covers the basic purpose but omits details about output structure, pagination, and parameter semantics, making it only partially complete for an AI agent.

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

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

The schema descriptions cover 0% of the parameters, so the description must compensate. It does not explain the 'repo' and 'limit' parameters at all, leaving the agent to infer their meanings from names alone. This is insufficient given the low schema coverage.

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

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

The description clearly identifies the tool as returning 'Recent indexed commits for a selected repo.' This uses a specific resource (commits) and scope (repo), making the core function unambiguous. However, it does not explicitly distinguish itself from sibling GitHub tools like github_open_issues or github_search, nor does it explain what 'indexed' means.

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

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

The description does not provide direct guidance on when to use this tool versus other GitHub tools. Instead, it strongly recommends using cuecrux_session for routing, implying this tool should not be called directly in many cases. This is more about session-level routing than about the tool's specific usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains what is searched and the scope, but does not disclose return format, pagination, rate limits, cost, or any side effects. The behavioral info is largely about routing (cuecrux_session) rather than about this tool's own runtime behavior, leaving significant gaps for the agent.

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

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

The description is reasonably concise: the first paragraph is a single sentence stating the purpose, and the second paragraph gives routing guidance. While slightly verbose in the repeated emphasis on using cuecrux_session, each sentence contributes to understanding the tool's role in the broader system. It is not overly bloated and is well front-loaded.

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

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

The description gives important context about the routing architecture (cuecrux_session) and the corpus scope, but it is incomplete for the tool itself. There is no output schema, so the description should explain return values, but it does not. It also does not explain how to use parameters or how this tool differs from the specialized GitHub siblings. The lack of these details makes the description incomplete for an agent to invoke the tool effectively.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters (repo, query, top_k). It only mentions that repos are 'selected via /v1/integrations/github/repos', but does not clarify the 'repo' parameter's role or the meaning of 'query' and 'top_k' beyond the schema's bare types and constraints. The description provides essentially no added value for parameter understanding.

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

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

The description clearly states the tool 'Search[es] the indexed GitHub corpus (commits, PRs, issues, comments)' with a specific verb and resource scope. It also notes the corpus is 'under repos selected via /v1/integrations/github/repos', which adds useful context. However, it does not explicitly distinguish itself from sibling tools like github_open_issues or github_recent_commits, which are more specialized.

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 strong routing guidance: it explicitly says to 'Prefer cuecrux_session' and that this tool 'remains directly callable for backward compatibility; the collapsed surface is the intended surface.' This clearly signals when to use the tool (as a fallback) and names the preferred alternative. It does not, however, give guidance on when to use this vs. the specialized GitHub siblings.

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

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

No annotations are provided, so the description carries the full burden. It states only the basic action and routing context, without disclosing behavioral traits such as side effects, required permissions, idempotency, or what happens after an invitation is sent. This is insufficient for a tool that creates an external effect.

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 purpose is front-loaded, but the second paragraph about cuecrux_session is verbose and could be shortened. The routing guidance is useful, but the description spends a lot of words on it rather than on the tool's own behavior.

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 with two params and no output schema, and the description covers the purpose and routing. However, it lacks information about return values, error conditions, or preconditions (e.g., whether the user must exist). The routing guidance is helpful but does not fully compensate for missing context on the invitation outcome.

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

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

Schema description coverage is 100%: both email and role have descriptions. The description adds no additional parameter semantics beyond echoing 'by email address' from the schema. Given the high schema coverage, 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 opens with a specific verb+resource: 'Invite a new member to the organisation by email address.' This clearly distinguishes the tool from siblings like change_seat_role and revoke_seat, which handle different seat-related actions.

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

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

The description provides explicit routing guidance: 'Prefer `cuecrux_session` as your first and only direct MCP call' and notes that this tool remains for backward compatibility. This clearly indicates when to use the session plan over direct invocation, though it does not name alternative seat-management tools.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions a 'credit pledge' but does not explain what happens on join, whether credits are deducted, if there are costs, side effects, or reversibility. The extra paragraph focuses on cuecrux_session rather than join_coalition's own behavior.

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

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

The first sentence is clear and front-loaded. The second paragraph contains useful routing context but is somewhat verbose and tangential to the tool itself; still, every sentence contributes guidance, so it earns a solid score rather than maximum.

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 with full schema coverage, but it has no output schema and no annotations. The description explains the purpose and routing preference but omits important context about the effects of joining, the pledge mechanics, and possible return values, leaving a moderate gap.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the concept of a 'credit pledge,' which aligns with the pledge_crux parameter, but does not go beyond what the schema already documents for either parameter.

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

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

The description opens with a specific verb and resource: 'Join an existing coalition with a credit pledge.' This clearly states the action and target, and the word 'existing' distinguishes it from the sibling tool create_coalition.

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

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

The description gives explicit routing guidance: 'Prefer cuecrux_session as your first and only direct MCP call' and explains it returns a plan that routes this tool to the preferred channel, tier, and cost class. It also notes backward compatibility, making the intended usage hierarchy clear.

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

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

With no annotations, the description carries the full burden. The phrase 'List all projects' strongly implies a read-only operation, and mirroring a /v1/projects endpoint adds a concrete behavioral anchor. However, it does not explicitly disclose read-only semantics, auth needs, or potential side effects, leaving room for ambiguity in a zero-annotation environment. The backward-compatibility note adds some insight into the tool's lifecycle but not its runtime behavior.

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

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

The first sentence is a clean, front-loaded purpose statement. The second paragraph, while relevant to usage, is somewhat verbose with multiple explanatory sentences about cuecrux_session and routing truth. It earns a 4 rather than 5 because the routing guidance could be tightened without losing meaning, but it is still well-structured and not wastefully long.

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

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

For a parameterless list tool with no output schema, the description covers the essential context: what it lists, the API mirror, and the strategic usage directive. It does not detail response format or edge cases, but these are not required given the tool's simplicity and the absence of output schema. The guidance to prefer cuecrux_session also frames the tool's role in the broader MCP surface.

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 zero parameters, the schema is trivially documented, and the baseline is 4. The description enriches by clarifying the tool lists 'all projects,' which is the only parameter-related semantic needed. No further parameter explanation is required, and the description does not introduce confusion.

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

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

The description opens with 'List all projects on the configured Crux Daemon,' which is a specific verb+resource statement. It also distinguishes the tool by the qualifier 'all' and by naming the daemon, separating it from sibling tools like list_work or get_project_context. The reference to the corecruxd API further pins down its exact scope.

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

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

Explicit usage guidance is provided: 'Prefer cuecrux_session as your first and only direct MCP call' and 'This tool remains directly callable for backward compatibility.' This clearly states when not to use the tool and names the preferred alternative, going beyond simple context to direct routing decisions.

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

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

With no annotations provided, the description carries the full burden, but it only states the core function. It does not disclose pagination behavior, read-only guarantees, or any rate limits/limitations, leaving the agent to infer these from the schema or tool name. The routing paragraph, while useful, does not address the tool's behavioral traits.

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

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

The core purpose is front-loaded in a single sentence, and the routing guidance is clear and imperative. The second paragraph contains some redundancy ('one call per session is enough', 'source of routing truth') but remains compact and purposeful, earning a high score.

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

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

The description fully covers the tool's purpose and the critical routing directive, making it usable for an agent. It doesn't describe return format, but for a list tool with no output schema, the response shape is predictable. The tool's simplicity and complete schema descriptions further reduce the need for additional 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?

The input schema already provides 100% coverage for both `limit` and `cursor`, so the description adds no extra parameter-level detail beyond what the schema offers. Since schema coverage is high, the baseline of 3 is appropriate; the description does not harm or significantly enhance parameter understanding.

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 the specific verb 'list' with the resource 'seats' and scope 'current organisation', clearly distinguishing it from sibling tools like invite/revoke/change_seat_role. The parenthetical '(members)' further clarifies terminology, making the tool's function unmistakable.

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 explicitly instructs the agent to prefer `cuecrux_session` as the first and only direct MCP call, and states this tool remains directly callable only for backward compatibility. This clearly tells the agent when not to use this tool and points to the intended alternative, which is strong usage guidance.

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

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

No annotations are provided, so the description carries the burden. It adds useful context such as 'kanban surface for cross-agent coordination' and notes that the tool is 'directly callable for backward compatibility.' While it doesn't explicitly mention read-only behavior or return format, the verb 'list' implies a non-mutating operation. The added context about backward compatibility and the collapsed surface goes beyond the basic functionality, contributing meaningful behavioral insight.

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 first paragraph is concise and front-loaded: 'List work items, optionally filtered by project_id, state, tenant_id, assignee_passport. The kanban surface for cross-agent coordination.' The second paragraph is longer but purposeful, providing routing guidance. It is slightly verbose but each sentence contributes to the overall value, so the structure earns a 4.

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 has 4 optional parameters, no output schema, and no annotations. The description covers the core purpose, the optional filters, and gives important routing context via cuecrux_session. It does not specify return format, sorting, or pagination, but for a simple list tool, the information is sufficient to guide an agent on when and how to call 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?

With 0% schema description coverage, the description must compensate. It does list the four filter parameters ('project_id, state, tenant_id, assignee_passport') and states they are optional filters, which adds value. However, it does not explain the meaning of each parameter (especially domain-specific terms like 'passport') or describe the state enum values. This is minimal but non-zero help.

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 'List work items, optionally filtered by project_id, state, tenant_id, assignee_passport.' This is a specific verb (list) and resource (work items), with explicit filter parameters. It also differentiates itself as 'The kanban surface for cross-agent coordination,' distinguishing it from other work-related tools.

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

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

The description provides explicit guidance: 'Prefer `cuecrux_session` as your first and only direct MCP call... This tool remains directly callable for backward compatibility; the collapsed surface is the intended surface.' This tells the agent when to use this tool (backward compatibility) versus the preferred alternative (cuecrux_session), which is a clear usage direction.

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

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

No annotations are provided, so the description carries the full burden. It discloses the routing preference and backward-compatibility status, and that it resolves content from memory_session_init's on-demand list. However, it does not mention whether this is a read-only operation, what side effects exist, or what happens when an engram is missing. Partial transparency at best.

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 paragraphs, with the first sentence immediately stating purpose and trigger. The second paragraph about cuecrux_session is a bit lengthy and redirects attention away from this tool's direct function, but it contains essential routing context. Overall efficient and well-structured.

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

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

For a tool with no output schema and no annotations, the description covers the input source (available_on_demand), trigger condition, and routing preference. However, it does not explain what the successful output looks like or how errors (e.g., unresolved engrams) are handled. Some return/error context would improve 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%, with each parameter (names, modelId, manifestHash) already described in the schema. The description adds the link to memory_session_init and trigger features, but provides no additional parameter-level semantics. This meets 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 states the tool's action: 'Resolve body content for engrams listed in memory_session_init.available_on_demand.' It also gives a precise trigger condition ('matches an on-demand engram's applies_when or trigger_features'), which distinguishes it from memory_retrieve and memory_reason_about. This is a specific verb+resource with clear scope.

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

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

Explicitly tells when to use: 'Use when a question matches an on-demand engram's applies_when or trigger_features.' It also name-drops the preferred alternative, cuecrux_session, and explains this tool remains 'directly callable for backward compatibility.' That is clear guidance on when to choose this tool versus the routing tool.

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

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

No annotations are provided, so the description carries full behavioral disclosure burden. It mentions the cached Pattern B prompt and the collapsed-surface/backward-compatibility status, which adds context, but it does not disclose side effects, permissions, rate limits, or return-value behavior, leaving notable gaps.

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

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

The description is front-loaded with a clear purpose sentence followed by dense routing guidance. It is structured into two focused paragraphs with no fluff, though slightly longer than strictly necessary, but every sentence contributes useful information.

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

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

The tool has no output schema and no annotations, so the description should explain return behavior and prerequisites. It implies dependency on prior memory_retrieve calls through parameter descriptions, but does not state what the reasoning output looks like or any post-processing steps, making it moderately complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-specific semantics beyond the schema; phrases like 'previously retrieved memory chunks' and 'optional curated facts' simply mirror the schema's `chunks` and `facts` descriptions.

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

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

The description clearly states the tool reasons over previously retrieved memory chunks and optional curated facts using the cached Pattern B prompt. It also distinguishes itself from the sibling `cuecrux_session` by positioning it as the preferred entry point, while this tool remains for backward compatibility.

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

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

The description explicitly instructs the agent to prefer `cuecrux_session` as the first and only direct MCP call and states that it returns a typed capability plan routing this tool appropriately. It also clarifies that this tool is a backward-compatibility surface and that the collapsed surface is intended, giving clear when-to-use guidance.

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

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

No annotations are provided, so the description carries the full behavioral transparency burden. It usefully discloses that `pre_logic` is a ready-to-inject system prompt preamble calibrated to the model's capability class and that `enumerated_facts` may be inlined under deterministic pre-execution. However, it does not mention read-only guarantees, auth requirements, or behavior on empty results or errors, leaving significant gaps.

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 organized into two focused paragraphs: one for function and response behavior, one for routing guidance. It is mostly efficient, though phrases like 'the collapsed surface is the intended surface' introduce jargon without adding clear value.

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

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

The tool has seven parameters and no output schema, so the description must compensate for missing return-value documentation. It explains pre_logic and enumerated_facts but does not describe the overall response shape, error conditions, or how this tool relates to memory_reason_about and memory_engrams_resolve, leaving notable gaps for a complex retrieval tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself does not add parameter-level detail beyond what the schema already provides; it only restates the calibration effect of modelId. This is adequate but adds no extra semantic value.

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

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

The description opens with a specific verb ('Retrieve') and names exact resources (memory chunks, curated ESI facts, passport-driven engrams) and the intended purpose ('Pattern B memory reasoning'). This is specific enough to distinguish it from sibling tools like memory_reason_about or memory_engrams_resolve.

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

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

The description explicitly instructs the agent to prefer `cuecrux_session` as the first and only direct MCP call, states one call per session is enough, and notes that this tool remains directly callable only for backward compatibility. This provides clear when-to-use and when-not-to-use guidance with a named alternative.

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

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

No annotations are provided, so description carries the full behavioral burden. It discloses that the session is 'server-controlled,' returns deterministic outputs, and is meant for one-time use; however, it does not explicitly state side effects (e.g., whether session state is created) or that repeated calls are idempotent, leaving some ambiguity.

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

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

Two concise paragraphs front-load the primary action and outputs in the first sentence, then give routing guidance without repetition. Every sentence adds useful information; no filler.

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

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

For a one-parameter, no-output-schema tool, the description covers purpose, returns, usage sequence, and alternative routing. It could elaborate on failure modes or the exact meaning of 'engram manifest,' but it is largely sufficient for correct invocation.

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

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

Schema coverage is 100% and the modelId parameter is fully documented in the schema ('Used to calibrate the manifest'). The description adds no additional parameter information, so it meets baseline but no more.

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

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

Clearly states it 'boots a memory reasoning session' and returns four specific artifacts (session procedure, passport identity, capability class, engram manifest). Distinguishes itself from siblings by positioning as a prerequisite for memory_retrieve and by contrasting with cuecrux_session.

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 instructs 'Call once before memory_retrieve when the session-init endpoint is enabled' and names cuecrux_session as the preferred alternative for routing. Provides clear 'when-to-use' and 'when-not-to-use' via the backward compatibility note.

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

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

No annotations are provided, so the description must carry the burden. It discloses the core effect (prevents garbage collection) and notes backward compatibility, but does not detail behavior around optional parameters like expires_at, idempotency, or potential side effects. This is more than a tautology but leaves several behavioral aspects implicit.

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

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

The description is front-loaded with the primary purpose and includes a compact paragraph on routing guidance. Each sentence carries informational weight, though the routing paragraph could be slightly tighter without losing meaning.

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 pin tool with fully documented optional parameters, the description provides purpose, usage guidance, and routing context. It lacks explicit return-value or error-handling details, but the schema and simple nature of the tool make this acceptable.

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

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

The input schema already covers all three parameters with 100% description coverage, so the baseline is 3. The description does not add any parameter-specific semantics beyond what the schema provides, which is acceptable given the full 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 first sentence clearly states the tool's function: 'Pin a receipt to prevent it from being garbage collected.' This is a specific verb-resource pair with a clear purpose, distinguishing it from sibling tools like get_stale_pins or diff_receipts.

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

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

The description explicitly instructs users to prefer cuecrux_session as the primary entry point and describes this tool as backward-compatible direct access. This provides clear routing guidance, though it does not enumerate alternative use cases beyond the general preference for cuecrux_session.

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

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

With no annotations, the description carries the full burden and does well: it reveals the tool creates an async job, chunks and hashes the artefact, produces a Merkle receipt, and returns a job ID. It does not mention potential side effects like cost or failure modes, but the core behavior is transparent.

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

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

The description is front-loaded with its primary purpose in one concise sentence, followed by a brief process explanation. The second paragraph on routing is somewhat verbose but justified for proper usage. Overall, it is well-structured and not bloated.

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

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

Given no output schema and no annotations, the description covers the main context: the async nature, processing steps, return value (job ID), and routing preferences. It does not explain the mode enum or how to retrieve the receipt, but these are covered by the schema and sibling tools like get_proof_status, making the description sufficiently complete.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add parameter-specific details beyond what the schema already provides; it only refers to the artefact and chunking at a high level, not to mode or metadata 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 opens with a specific verb and resource: 'Submit a document artefact for cryptographic proof.' It clearly distinguishes this tool from siblings like get_proof_status and get_proof_receipt by outlining the full async job lifecycle: retrieves, chunks, hashes, and produces a Merkle receipt, returning a job ID for polling.

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 guidance is explicit: 'Prefer cuecrux_session as your first and only direct MCP call' and 'This tool remains directly callable for backward compatibility; the collapsed surface is the intended surface.' This tells the agent to use the session router instead unless direct invocation is needed.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not describe what happens upon purchase, such as debiting credits, adding a bundle, requiring authentication, or possible failure modes. The guidance about cuecrux_session is about routing, not the purchase behavior itself.

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

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

The description is front-loaded with the one-sentence purpose, followed by a concise paragraph about preferring cuecrux_session. Each sentence serves a distinct function (purpose, preferred routing, backward compatibility), though the middle sentence is slightly verbose with redundant phrasing like 'first and only direct MCP call' and 'one call per session is enough.' Overall, it 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?

This is a purchase transaction tool with no output schema and no annotations. The description does not explain the purchase flow, return values, side effects, or prerequisites. It heavily steers users to cuecrux_session instead, but for direct invocation, it leaves significant gaps in what the agent can expect.

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 bundle_id and metadata, so the baseline is 3. The description adds minimal extra meaning beyond the schema—'by ID' is trivial given the schema already states 'The bundle ID to purchase.' No additional context is provided for metadata beyond its optionality.

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

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

The description opens with 'Purchase a credit bundle by ID,' which is a specific verb (purchase) and resource (credit bundle) with a scoping parameter (by ID). This clearly distinguishes it from sibling tools like browse_bundles and get_pricing. The purpose is unambiguous.

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

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

The description explicitly instructs to 'Prefer cuecrux_session as your first and only direct MCP call' and notes that it routes this tool to its preferred channel, tier, and cost class. It further states this tool remains 'directly callable for backward compatibility,' giving both when-to-use and when-not-to-use guidance. This is a clear, explicit alternative.

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

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

No annotations are provided, so the description carries full responsibility. It discloses the semantic-search behavior and the routing/session plan, but omits operational details such as result format, cost implications, or explicit read-only confirmation beyond the verb 'retrieve.' The routing context adds some transparency but leaves gaps.

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 purpose is front-loaded in the first sentence, and the second paragraph delivers important routing guidance. However, the routing paragraph repeats 'first and only direct MCP call' and 'one call per session,' making it slightly more verbose than necessary while remaining 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?

The routing instructions provide key contextual information about how this tool fits into the session plan, and schema coverage is complete. Without an output schema or annotations, the description doesn't explain return values or side effects, but the retrieval context and backward-compatibility note make it reasonably complete for invocation.

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

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

The input schema already documents all five parameters with descriptions (100% coverage), including enum values and defaults, so the baseline is met. The description contributes no additional parameter-level meaning, instead focusing on session routing.

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

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

The description opens with a specific verb ('Retrieve') and resource ('vault'), clearly indicating semantic search across one or more corpora. It distinguishes itself from direct invocation by explaining the preferred cuecrux_session path, though the core purpose remains unambiguous.

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

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

Explicitly instructs the agent to prefer `cuecrux_session` as the first and only direct MCP call, with this tool remaining directly callable only for backward compatibility. This gives clear when-to-use guidance and names the preferred alternative, exceeding a simple statement of 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?

With no annotations, the description must carry the full transparency burden. It does disclose that the query is 'trust-routed' and 'respects budget constraints,' which are meaningful behavioral traits. However, it omits details such as whether the operation is read-only, what side effects occur (e.g., credit spend), or how budget limits are enforced when exceeded. The focus on the routing plan is meta-guidance rather than tool-specific behavioral disclosure.

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

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

The description is front-loaded with a clear one-sentence definition, followed by a second paragraph of necessary routing guidance. While slightly longer than the minimal two-sentence ideal, every sentence contributes to either defining the tool or steering the agent to the preferred alternative. No filler or redundant phrasing.

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

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

Given the absence of an output schema and no annotations, the description should clarify what the tool returns or what happens after execution. It does not describe result format, error behavior, or budget violation outcomes. The routing guidance is thorough, but the tool's own operational behavior is only partially covered, leaving gaps for an agent relying solely on this description.

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