VaultCrux Memory Core

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does mention the need for operator-class credentials and the add/supersede action, but it omits details about side effects of superseding, reversibility, or idempotency, leaving important behavioral traits undisclosed.

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

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

The description is a single sentence with no filler, but it is slightly dense and the phrase 'by the API' is redundant. Overall, it is efficient but could be clearer in structure.

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

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

Given the tool's complexity (7 parameters, nested objects, output schema), the description is far too sparse. It fails to address parameter semantics, return values, or any usage prerequisites beyond credentials, making it inadequate 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 description coverage is 0%, and the description does not explain any of the 7 parameters. Cryptic fields like 'situation_fingerprint' and 'expected_sufficiency_min/max' are left undefined, forcing the agent to guess their meaning.

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

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

The description clearly states a specific action ('Adds or supersedes') on a specific resource ('AgentCharacterKernel'), making the tool's purpose obvious. It also highlights the privileged nature, distinguishing it from general access tools like get_character_kernel.

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

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

The description implies usage is restricted to privileged curation and notes that operator-class credentials are required, but it does not explicitly contrast with alternatives like submit_correction or update_constraint, nor does it provide clear 'when to use' guidance beyond the privileged 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?

With no annotations, the description carries the full burden and does well: it discloses that submitting triggers coverage re-assessment, follow-up question selection, and automatic output routing to specific record types. It also states the return value. It omits details like auth or idempotency, but the disclosed side effects are substantial.

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

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

Three sentences, front-loaded with the primary action, and every sentence adds meaningful information about process or outcome. No fluff or redundancy.

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

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

The description covers the core behavior, side effects, routing, and return value. An output schema exists, so return structure is delegated. It is sufficiently complete for an agent to invoke the tool and understand the consequences, though it could mention prerequisites like an active session.

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 by explaining parameters, but it does not. It only mentions 'an answer' generically; it does not clarify the expected format of answer, the meaning of session_id, or the role of question_id. Parameter names and schema types provide some hints, but the description adds little 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 uses a specific verb ('Submit an answer') and clearly identifies the resource ('an elicitation question'). It also distinguishes this tool from siblings like run_elicitation by describing the submission action and its downstream effects.

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

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

The description implies usage in the context of an active elicitation session (submitting an answer to a question) and clarifies what happens next (follow-up question or completion). It does not explicitly mention when not to use it or name alternatives, but the context is clear enough.

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 reveals the tool's role as a sufficiency gate, lists the return fields (answerable, missing fields, contradictory fields, recommended next tool, confidence), and explains the consequence of answerable=false. This adds significant context beyond the schema.

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

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

The description is front-loaded with the core concept ('Sufficiency gate'), then expands with usage guidance and return values. Every sentence serves a purpose, and the total length is appropriate for the tool's complexity.

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 purpose, usage, behavior, and parameters. It even summarizes the output structure, which is helpful despite the existence of an output schema. For a decision-gate tool with simple parameters, this is complete and well-rounded.

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 coverage is 0%, but the description compensates by explaining both parameters: 'Pass your query and optionally the fact rows you have gathered.' This adds meaning beyond the bare schema by telling the caller exactly what to provide for each 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 clearly states the tool's purpose: 'can this question be answered with current evidence?' It uses a specific verb ('assess') and resource ('answerability') and distinguishes itself from sibling tools like assess_coverage and assess_delegation_readiness by focusing on sufficiency for answering a 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?

Provides explicit usage guidance: 'Use this BEFORE forcing a best-guess answer.' It also gives a clear decision rule: if answerable=false, say 'insufficient evidence' rather than guessing wrong. This is direct and actionable.

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 responsibility for disclosing side effects and operational behavior. It states the tool runs a sweep and returns events, suggesting a potentially resource-intensive operation, but it does not mention whether it is read-only, what permissions are needed, what side effects occur, or how the sweep behaves under edge cases.

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

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

The description is a single, front-loaded sentence that wastes no words. It leads with the action verb and key resource, making it easy to scan. The length is appropriate for the provided information.

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

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

Given the tool has 4 parameters, no annotations, and an output schema, the description is too thin. It lacks parameter semantics, side-effect disclosure, and guidance on prerequisites or edge cases. While the output schema covers return values, the other gaps make the description incomplete for reliable agent invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It weakly relates to window parameters via 'requested window' and agent via 'for an agent,' but it entirely omits the meaning of min_decision_count and gives no detail on window format or constraints. This is insufficient for a 4-parameter tool.

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

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

The description uses specific, actionable language: 'Run the on-demand AgentCharacterKernel distribution-layer sweep' and 'return emitted drift events.' It clearly identifies the resource (AgentCharacterKernel), the action (sweep), and the result (drift events for a window), distinguishing it from sibling assessment 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 phrase 'on-demand' implies the tool is used when a manual drift check is needed, and 'for the requested window' scopes the usage to a time range. However, there is no explicit guidance on when to prefer this over alternatives or when not to use it, so usage context is only implied.

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

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

No annotations are provided, so the description carries full burden. It describes outputs (artefact counts, freshness stats, knowledge gaps) and implies a read-only check, but does not explicitly confirm non-mutation, side effects, or any special requirements. It adds some behavioral context but not fully 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?

Three sentences, front-loaded with a clear summary ('Question-scoped readiness check'), and each sentence adds value. It is appropriately concise and well-structured with no redundancy.

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

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

With an output schema present, return values are already covered. The description covers purpose and usage well, but the lack of parameter explanations for optional fields leaves a gap in completeness. It is adequate but not fully complete for a tool with three parameters and no schema descriptions.

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 has 0% parameter descriptions, so the description must compensate. It mentions 'task_description' indirectly ('Given a task description') but does not explain 'domains' or 'action_types' at all. These parameters remain ambiguous in meaning and 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 clearly states the tool's purpose with a specific verb ('returns') and resource ('what the system knows and doesn't know'). It distinguishes itself from siblings by framing as a question-scoped readiness check that answers 'do I have enough evidence to answer this?'.

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 usage guidance: 'Use BEFORE answering to decide if you should search more or commit.' It also advises searching with different terms when coverage is thin. This gives clear context, though it does not explicitly mention when not to use it or name 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 the full burden. It discloses the return format (readiness signal, gaps, actions) and implies a read-only assessment, but does not explicitly state whether there are side effects, permissions required, or external data dependencies. Some behavioral context is added, but significant gaps remain.

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

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

The description is concise (three sentences) and front-loaded with the primary purpose. Every sentence adds value: the first states what it is, the second details the dimensions and outputs, and the third clarifies usage boundaries. No redundancy or fluff.

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 explains the tool's purpose and return value well, and an output schema is present. However, it fails to describe the input parameters (0% coverage), and without annotations, the safety and side-effect profile is unclear. For a two-parameter tool, this is a notable gap, making it only partially 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 0%, and the description does not mention either parameter (operator_id or task_description). It adds no meaning beyond the parameter names provided in the schema, failing to explain their roles, requiredness, or relationship to the assessment.

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 performs a multi-dimensional delegation readiness assessment and lists the specific dimensions checked (operator profile, operating rhythm, constraints, knowledge, decision framework). It explicitly differentiates itself from the sibling tool verify_before_acting by noting it is the 'pre-flight check for delegation, not for 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 states when to use the tool ('pre-flight check for delegation') and when not to use it ('not for action'), naming the alternative tool (verify_before_acting). This is clear usage guidance relative to at least one sibling.

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 burden of behavioral disclosure. It mentions the tool is 'deterministic', normalizes dates, returns events sorted chronologically, and separates unresolved events. These are meaningful behavioral traits beyond basic operation, though it does not discuss state changes or potential side effects.

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

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

The description is three sentences long, front-loaded with the core purpose, and every sentence adds value. It avoids redundancy and is easy to parse.

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 a solid overview of the tool's core functionality and use cases, but it lacks parameter explanations and edge-case behavior. Since the tool has moderate complexity and no annotations, the description 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?

The schema has 4 parameters with 0% description coverage, so the description must compensate. It only implicitly references the 'query' parameter and gives examples that hint at the 'relation' parameter, but it does not explain 'as_of' or 'anchor_event'. This is a significant gap 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 a timeline constructor that finds dated events, normalizes dates, and sorts them chronologically. This is a specific verb-resource combination, and the temporal focus distinguishes it from sibling tools like get_causal_chain or get_versioned_snapshot.

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 states when to use the tool: for 'what order', 'before/after', and 'earliest/latest' questions. This gives clear usage context, though it does not mention when not to use it or name specific alternative 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?

With no annotations provided, the description carries the burden of disclosing behavior. It clearly states that the tool returns supporting and contradicting evidence with confidence scores, and implies a read-only verification by saying 'before committing.' It does not disclose all potential side effects or failure modes, but covers the key behavioral aspects.

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

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

The description is two sentences, front-loads the core purpose, and contains no redundant information. Every sentence adds value, from the action verb to the decision rule.

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

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

Despite having no annotations, the description covers the essential purpose, usage context, input parameter (claim_text), and output characteristics. The output schema handles return value details, and the description's short length is sufficient for the tool's simplicity. The only gap is the undocumented optional parameters.

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 explain parameters. It only explains claim_text ('Pass your candidate answer as claim_text'), leaving limit and agent_id without any description. While these are optional and may be self-explanatory, the description does not add meaning for them beyond their names.

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 ('Verify') and resource ('a proposed answer against memory'), clearly distinguishing it as a pre-answer validation step. It also explains the core mechanism and mentions the candidate answer parameter, making the tool's purpose 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?

It explicitly states when to use the tool ('as a pre-answer gate') and provides actionable guidance on how to interpret results (investigate if contradicting evidence exists or support is weak). It does not explicitly name alternatives or state when not to use it, so it misses the top score.

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 evaluation behavior and output structure (matched constraints, match types, verdict). While it doesn't explicitly state read-only status or side effects, the verb 'check' and the return of a verdict strongly imply a non-mutating evaluation, which is reasonably transparent given no annotations.

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

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

The description is two sentences, front-loaded with the core purpose, and followed by a concise summary of outputs. Every word earns its place with no redundant or vague 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?

The tool has moderate complexity with 4 parameters, nested objects, and an output schema. The description gives a clear high-level picture but omits parameter semantics, which are poorly covered since schema descriptions are absent. The existing output schema mitigates the need to explain return values, but the parameter ambiguity leaves completeness just adequate.

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

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

Schema description coverage is 0%, meaning no parameter documentation exists in the schema. The description only hints that 'action_description' is the action to check, but it leaves team_id, metadata, and target_resources unexplained. This is a significant gap that the description fails to compensate for.

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 with a specific verb ('Check') and resource ('an action against all active constraints'). It distinguishes itself from siblings like get_constraints by detailing the output (matched constraints, match types, combined verdict), making its unique function evident.

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 clearly implies when to use the tool (when you need to check an action against constraints) and gives context on what it returns. However, it does not explicitly name alternatives or when-not-to-use conditions, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It describes the read-only nature implicitly ('check', 'cross-references') and details the output (composite verdict, per-module breakdown, recommendations). However, it does not explicitly state that the tool has no side effects, nor does it mention any prerequisites or rate limits, leaving moderate gaps in transparency.

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

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

The description is four sentences long and each sentence contributes value: it frames the purpose, explains the input sources, describes the return value, and gives usage guidance. The opening question is slightly stylistic but not wasteful. Overall, it is well-structured and 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?

Given the tool's moderate complexity, the description covers purpose, usage context, input sources, and return behavior. An output schema exists, so detailed return-value explanation is not required, but the description still mentions the composite verdict and per-module breakdown. It is complete for an agent to select and invoke the tool appropriately.

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 description coverage is 100%, so the baseline is 3. The description adds minimal parameter-specific meaning beyond the schema; it reinforces the role of 'changed_modules' but does not elaborate on 'changed_files' or 'deploy_target'. It provides conceptual context but not additional syntax or format 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 the tool's purpose: to determine if it is safe to deploy changes by cross-referencing changed modules against multiple data sources. It uses a specific verb ('cross-references') and resource ('your changed modules'), and it distinguishes itself from sibling tools by covering a composite set of checks (constraints, incidents, knowledge freshness, alerts) rather than a single concern.

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 when-to-use guidance: 'Use BEFORE deploying...' and lists what it catches. However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of the full '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?

With no annotations, the description carries the behavioral burden. It discloses that the tool creates a snapshot and records decisions, assumptions, and open questions, which implies a persistent write. Yet 'receipted' is undefined, and there's no mention of overwrite behavior, authorization needs, or what exactly the receipt contains.

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

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

The description is three sentences, sets the main action first, and every sentence contributes meaningful context: what it creates, what it records, and why it's useful. There's no redundancy or filler.

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

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

For a five-parameter write operation with no annotations, the description provides high-level purpose and content but omits required parameter semantics and behavioral details. The presence of an output schema doesn't compensate for the gaps in parameter guidance. It's adequate 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 description coverage is 0%, so the description must compensate. It names three content categories (decisions, assumptions, open questions) that map to optional array parameters, but it doesn't cover the required session_id and summary, nor explain the structure of decisions_so_far. This leaves the agent with insufficient guidance for building a valid request.

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 ('receipted snapshot of your current decision state'), making the primary purpose clear. It also conveys the resumption benefit, but it does not explicitly differentiate itself from sibling tools like record_decision_context or log_progress.

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

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

It clearly states the usage context: 'during a long-running session' and explains the benefit of resuming from the last checkpoint rather than replaying from zero. However, it doesn't mention when not to use it or compare it directly to 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 the full burden. It discloses temporal ordering, current flagging, return of current_value and has_multiple_versions, and an optional cached narrative summary based on a feature flag. This is useful beyond the schema, though it omits error handling or side effects.

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

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

The description is a single, organized paragraph covering definition, usage, examples, and return details. Each sentence adds value and there's no fluff, though it is a bit dense and could be broken into clearer sections.

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 an output schema exists, the description doesn't need to detail return values, but it still explains current_value and has_multiple_versions. It addresses the primary use case, examples, and a feature flag. It doesn't cover limitations or errors, but for this tool's scope it's sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. Entity and predicate are explained through examples, and as_of_current is implied by 'most-recent-before-as_of' but not explicitly defined. The optional nature of as_of_current isn't clarified, leaving some 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 clearly states it provides a temporal-ordered view of all values for an (entity, predicate) pair, flagging the most recent before a cut-off as current. It distinguishes from sibling tools by emphasizing the resolution of current value from historical versions, reinforced by concrete examples.

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 says 'Use this when the agent sees contradictory facts... and needs to know which is current,' giving a clear trigger scenario. It doesn't mention alternatives or when not to use, but the scenario is specific enough to guide appropriate invocation.

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 must disclose behavioral traits on its own. It only adds that the tool is called once at session start, but says nothing about side effects, idempotency, authorization, or how the declaration affects subsequent orchestration. This is a minimal disclosure, leaving the agent to guess about state changes and required setup.

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 no filler. It front-loads the core action and adds one essential usage detail, making every word earn its place.

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

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

Despite an output schema being present, the description omits critical information about what the tool returns, how models are used for routing, and the semantics of capability_class and latency_tier. The tool is likely simple, but the description's brevity leaves important gaps for an orchestration-related tool, especially when no annotations help fill the void.

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 provides no guidance on the two parameters (session_id and models). While the schema names are self-explanatory to some degree, the meaning of critical nested fields like capability_class and latency_tier (and their allowed values) is left entirely to the schema without any explanatory context, which is insufficient for a tool with no other prose.

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

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

The description uses a specific verb ('declare') and resource ('available models'), and clearly scopes the action to 'in this session for orchestration routing'. This distinguishes it from sibling tools like get_platform_capabilities or list_external_services, making the purpose immediately clear.

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

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

The description explicitly states when to call the tool ('Called once at session start'), providing clear context for usage. However, it does not mention alternatives or when not to use it, so it misses the full 'when-not' guidance that would earn a 5.

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

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

The description states 'This is a mutation operation', which is a useful disclosure, but with no annotations provided, the description carries the full burden. It does not explain side effects, idempotency, permissions, or what happens when a constraint is declared (e.g., whether it immediately becomes active). The disclosure is minimal.

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, concise and front-loaded with the core action. Every word earns its place, and it is appropriately sized for a simple declaration.

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 has 9 parameters, nested objects, and no annotations, this brief description is insufficient. It does not mention the output schema, success/failure behavior, or any edge cases. The low complexity of the text does not match the high complexity of the tool, leaving the agent without enough context to invoke it correctly.

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

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

Schema description coverage is 0%. The description does not explain any parameters except implicitly listing constraint_type values that already exist as an enum in the schema, adding no new information. Required parameters like 'assertion' and optional ones like 'scope', 'severity', and 'expires_at' are not described. The description fails to compensate for the lack of 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 action ('Declare') and the resource ('organisational constraint'), and enumerates the constraint types. It distinguishes from sibling tools like 'update_constraint' and 'get_constraints' by implying creation, but it does not explicitly say 'create' or contrast with 'suggest_constraint', so it is clear but not perfectly differentiated.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that you should use this instead of 'update_constraint' or 'suggest_constraint', nor does it give any context about prerequisites or use cases. This leaves the agent to infer usage from the name.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It explains the output and classification logic (delegation difficulty, elicitation signals) but does not explicitly state whether the operation is read-only or has side effects, nor any limitations or error conditions. The added behavioral context is useful but incomplete.

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

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

The description is two sentences, front-loaded with the main action and examples, and every sentence provides substantive information. It is concise and well-structured with 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 description provides a strong overview of the tool's functionality and output, and an output schema exists. However, the missing parameter guidance for depth and operator_id, along with no annotations or usage exclusions, leaves the description incomplete for a tool of this complexity despite its clear core explanation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the task_class parameter with examples, but does not mention the depth or operator_id parameters, leaving their semantics undefined. This is a significant gap for two of the three 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 description clearly states the tool decomposes a high-level task class into specific steps with detailed attributes (knowledge requirements, judgment requirements, delegation difficulty, etc.). It uses a specific verb 'decompose' and resource 'task class', with examples, and distinguishes its output (immediately delegable vs elicitation-first vs expert-only) from 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 implies usage when you have a high-level task class and need to break it down for delegation planning, and it explicitly mentions what it identifies. However, it does not explicitly state when not to use it or mention alternatives, so it provides clear context without exclusions.

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

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

With no annotations, the description carries the burden. It adds behavioral traits: 'Safe math' (non-destructive), 'deterministic result with a computation trace' (reliability and auditability). These go beyond what the schema provides, though it does not detail error cases or edge 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?

Three concise sentences with front-loaded purpose, a list of operations, and a usage instruction. No redundant 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 description covers purpose, usage, and behavioral outcomes. With an output schema present, return values don't need explanation. It references the upstream tool enumerate_memory_facts, creating a complete workflow. Minor gaps: missing details on operation semantics for edge cases, but overall adequate for a simple aggregation 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 schema has 0% description coverage, so the description must compensate. It adds meaning to 'rows' by specifying they come from enumerate_memory_facts, and lists the operations that match the enum. However, it does not explain subtle semantics like what 'difference' computes or how 'latest' is determined, leaving some interpretation to the agent.

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 'Safe math and selection over a fact row set' and enumerates the operations (sum, count, difference, max, min, latest, earliest). It distinguishes itself from sibling tools by explicitly instructing to pass rows from enumerate_memory_facts, indicating a specific input source and use case.

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

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

It provides clear context by saying 'Pass the rows from enumerate_memory_facts' and describes the type of questions it solves ('totals, comparisons, and which is highest'). However, it does not explicitly mention when not to use it or alternative tools, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state a key outcome ('The skill is marked as dismissed and will not be promoted'), which is more than a bare mutation. However, it lacks details on reversibility, permissions, or what happens to the submission record beyond the status change. This is adequate but not rich, so a 3 is appropriate.

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 a clear front-loaded action. The first sentence states the purpose and target, and the second adds a critical consequence. Zero wasted words 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?

For a simple tool with an output schema, the description adequately covers the core behavior and outcome. It identifies the applicable submission states and the finality ('will not be promoted'). It does not explicitly discuss how this differs from retract_skill or what happens to the submission entry, but these are minor gaps. Given the tool's simplicity and schema richness, a 4 is justified.

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

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

Schema description coverage is 100%, so the input schema fully documents all three parameters (submission_id, reason, notes). The description adds no additional parameter-level meaning (e.g., relationship between 'reason' and 'dismissal' process). Per calibration, baseline is 3 when schema coverage is high, and no extra semantics are 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 description clearly states the tool's function: 'Dismiss a pending or quarantined skill submission.' It specifies the verb (dismiss), the resource (skill submission), and the applicable states (pending or quarantined). The added consequence 'will not be promoted' differentiates it from sibling tools like promote_skill and retract_skill.

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 clear context for when to use the tool: only for pending or quarantined submissions. However, it does not explicitly name alternative tools or state exclusions (e.g., do not use for already promoted submissions). This is clear context without explicit exclusions or sibling tool references, matching a 4.

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 determinism, the structured row set, the inclusion of missing_dimensions, and the exact predicate lookup mode without text search. It also mentions the feature flag for aggregation behavior. It does not explicitly state whether the tool is read-only or describe side effects, but the 'extraction' framing implies a non-mutating operation.

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

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

The description is long and dense, packing multiple ideas into a single paragraph without clear structure. It is not front-loaded with a high-level summary before diving into mode details and feature flags. While every sentence carries some information, it could be better organized with bullet points or separated paragraphs for readability.

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

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

The description covers the tool's primary use cases, output format, and aggregation mode, but it omits explanations for many parameters (as_of, limit, category, etc.) and does not fully elaborate on the interaction between modes and parameters. Given the tool's complexity and the presence of an output schema, the description is not complete enough for an agent to confidently use all features without additional inference.

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

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

The input schema has 13 parameters and zero descriptions (0% coverage). The description mentions only a subset: query, predicate, projectionVersionTag, mode, dedup_by_object, and expected_entity_types. It leaves as_of, limit, category, predicates, subject_match, expand_synonyms, and dedup_by_subject_root unexplained. This is a significant gap given the schema provides no descriptions, so the description does not sufficiently 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 clearly states the tool's function: 'Deterministic fact-table extraction for aggregation questions and curated ESI lookups.' It specifies the output format (structured row set) and distinguishes from prose-generating alternatives by targeting 'how many', 'total', 'list all' questions. The focus on counting rows rather than relying on LLM enumeration differentiates it from 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 explicitly says 'Use this for how many, total, list all questions' and contrasts with 'hoping the LLM enumerates correctly.' It provides specific instructions for curated ESI facts (pass predicate and optional projectionVersionTag) and explains the aggregation mode and its server-side requirement. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses that the tool packages reasoning state, routes to a human, and preserves work, but it does not describe potential side effects, whether the escalation blocks the current workflow, or what happens after routing.

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

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

The description is three sentences, front-loaded with the main action, and contains no redundant content. The em-dash label is a minor stylistic choice but does not waste 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 description covers purpose, usage, and core components, but lacks guidance on 4 of 7 parameters and does not discuss side effects or return behavior beyond the existence of an output schema. For a complex tool with no annotations and no schema descriptions, these gaps make it only partially 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 schema has 0% description coverage, so the description must compensate. It explicitly names evidence_gathered, options_considered, and recommended_action, but does not explain the required 'question' and 'reasoning' parameters, the 'urgency' enum semantics, or 'session_id'. This partial coverage is insufficient for a 7-parameter tool.

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

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

The description clearly states the tool performs contextual escalation by packaging the full reasoning state and routing it to a human for review. It uses specific verbs ('packages', 'routes') and identifies the resource (full reasoning state), distinguishing it from sibling tools like get_escalation_recommendation.

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 states when to use: 'Use when you hit genuine uncertainty that the system cannot evaluate.' It provides clear usage context but does not mention alternatives or explicit when-not-to-use conditions.

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

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

No annotations are present, so the description carries the full burden of explaining behavior. It discloses that the tool fetches neighboring turns and recovers nearby facts without indicating state mutation. While it doesn't explicitly state read-only or discuss rate limits/pagination, the fetch/expand framing strongly implies a non-destructive retrieval operation.

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

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

The description is two sentences, front-loaded with a clear summary, and enhanced with concrete examples that add value without waste. It is concise and every sentence contributes to understanding the tool's 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?

For a tool with three parameters and an output schema, the description covers the core use case and behavior well. However, it omits any explanation of the `mode` enum and leaves the exact role of `hit_ids` implicit. This is a notable gap, though the presence of an output schema reduces the need to describe return values.

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 only hints at the radius_turns parameter via '±N turns'. The mode parameter (turn/session/window) is completely unexplained, and hit_ids semantics are only weakly implied by 'promising retrieval hits'. The description does not adequately compensate for the schema's lack of parameter 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?

Description uses a specific verb ('fetch') and resource ('±N turns from the same session'), clearly distinguishing it from generic context retrieval. Concrete examples like 'my parents' and 'Disney+' make the purpose vivid and actionable. It is not a tautology and stands apart from sibling tools like get_relevant_context.

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

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

Provides an explicit conditional: 'When you find a relevant chunk but the specific fact is in a nearby turn, use this'. This is clear context for when to invoke the tool. However, it does not mention when not to use it or name alternative tools, so it falls short of a full 5.

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

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

With no annotations provided, the description fully carries the behavioral disclosure burden. It reveals side effects (emitting facts to the projection stream), idempotency ('duplicate fact_hashes skipped unless overwrite_existing=true'), return values ('facts_added + rules_matched + receipt_id'), and a server-side gating condition ('FACT_EXTRACTION_MODE'). This level of transparency exceeds typical descriptions and gives the agent crucial operational context.

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

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

The description is information-dense but every sentence adds value: it covers the action, use case, idempotency, profiles, return values, and gating. There is no redundancy or filler, and the key facts are front-loaded—the opening sentence immediately establishes what the tool does. This is an exemplary balance of conciseness and completeness.

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

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

The description is highly complete given the tool's complexity and the existence of an output schema. It explains when to use the tool, what it returns, the extraction profiles, and idempotency. Minor gaps remain: the meaning of 'seeded sessions' and how session_ids interacts with the scan scope is unclear, and the output schema (not provided in the prompt) would handle return value specifics. Still, the description provides sufficient context for most use cases.

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 does explain extraction_profile by listing its enum values and their behavior, and overwrite_existing is clarified in the idempotency note. However, the session_ids parameter is not explicitly described; the phrase 'seeded sessions' is ambiguous about whether it refers to all seeded sessions or is filtered by session_ids. Since one of three parameters lacks clear semantics, the description only partially compensates for the missing 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 clearly states the tool's function: 'Scan the tenant's seeded sessions with rule-based extractors' and 'emit structured facts to the projection stream so they become queryable via enumerate_memory_facts.' It specifies the resource (sessions), the action (extract facts), and the outcome (queryable facts), effectively distinguishing it from sibling tools like enumerate_memory_facts, which is referenced as the query counterpart.

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: 'Use when enumerate_memory_facts returns insufficient rows for aggregation, version-chain, or money questions and you suspect the fact exists but was under-predicated at ingest.' It also explains profile selection ('comprehensive' vs. narrower profiles) and emphasizes idempotency, making it safe to re-run. This clear guidance helps an agent decide when to invoke this tool versus 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?

With no annotations, the description carries the full burden of behavioral disclosure. It adds a cross-tenant credit constraint, which is useful, but it does not disclose side effects, permissions, reversibility, or validation behavior. It is not misleading, but it is insufficiently transparent 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 two sentences and front-loaded with the action. Both sentences earn their place: one states the purpose, the other a key condition. There is no wasted wording.

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

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

The tool has three required parameters, one of which is a nested evidence array, yet the description gives no guidance on how to construct a valid request (e.g., how to obtain a gap_receipt_id, what source types are valid). The output schema covers return values, but the description leaves operational details unexplained, making it incomplete for reliable 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?

Schema description coverage is 0%, so the description must compensate. It hints at 'gap' (mapping to gap_receipt_id) and 'new knowledge' (mapping to content), but does not explicitly explain any of the three parameters, especially 'evidence' which has a nested structure. The meaning of each parameter remains unclear.

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 ('fill') and resource ('previously reported gap') to state exactly what the tool does. It also distinguishes from sibling tools like 'get_knowledge_gaps' by implying an action that modifies state, and the cross-tenant credit rule adds a unique constraint.

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 clearly indicates the tool is for filling gaps that were previously reported, and the tenant requirement provides a specific context. However, it does not explicitly mention alternatives or when not to use the tool, so it lacks full explicit 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 full burden. It discloses the time window and scope but omits details about the 'limit' parameter behavior, default values, or whether the operation is strictly read-only. 'Get' implies read-only, but the description does not explicitly state it or describe any other 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 description is a single, well-structured sentence that front-loads the core purpose ('Get active watch alerts') and includes relevant scope and time context. No unnecessary words or repetition.

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

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

The description covers the core functionality clearly, and an output schema exists so return values do not need to be explained. However, it leaves the 'limit' parameter completely unexplained and does not mention default behaviors, which are necessary for an agent to invoke the tool correctly. This makes it adequate 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?

The input schema has one parameter ('limit') with zero description coverage, and the description does not mention 'limit' at all. The parameter name and schema constraints (min 1, max 100) make it partially inferable, but the description provides no added meaning, so a score of 2 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 specifies the action ('Get'), the resource ('active watch alerts'), and the scope ('across all watches for the tenant from the last 7 days'). This makes the tool's purpose immediately obvious and distinguishes it from other get_* 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 clear context on what data is returned (all watches, last 7 days) but does not explicitly mention when to use this tool versus alternatives or any exclusions. Since the context is clear and no exclusions are needed for a simple read, this earns a 4.

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 does so effectively by specifying return ordering ('sorted by recency'), filtering ('active constraints that still apply'), and the inclusion of 'correction history showing what was tried and reverted'. This goes beyond the schema and gives the agent useful expectations about output 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 two sentences plus a leading question, each earning its place. It opens with the core purpose, then the use case, then a high-level summary of returns. No fluff or repetition of schema 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?

Given that an output schema exists, the description need not enumerate return fields. It covers the 'why' (architecture rationale), 'when' (before refactoring), and 'what to expect' (decisions, active constraints, correction history). The tool has four parameters but only one required; the description provides enough context for an agent to invoke it correctly without missing critical information.

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?

All 4 parameters have descriptions in the schema (100% coverage), so the description adds limited parameter-specific value. It does implicitly explain the 'include' parameter by listing the artifact types, but the schema already enumerates them. The baseline of 3 is appropriate; the description does not compensate for any gaps because none exist.

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 concrete question ('Why is this module built this way?') and states the verb 'Aggregates' with a clear resource: all architectural decisions, constraints, corrections, and skills for a domain. This clearly distinguishes it from sibling tools like get_decision_context, which focuses on a single decision, by emphasizing the synthesis into a 'coherent narrative'.

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 says 'Use BEFORE refactoring or questioning a design choice', giving a clear when-to-use directive. It also hints at the value (compliance/performance/incident history) but does not mention when not to use or potential alternatives among siblings, so it misses the top score.

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. The verb 'Read' signals a non-mutating operation, which is a key trait. However, it does not disclose pagination behavior, ordering, error handling, or what exactly 'linked receipt hashes' entails, leaving gaps for a tool with zero annotation coverage.

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

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

The description is a single sentence, front-loaded with 'Read', and contains no filler. Every word contributes to identifying the tool's function and scope.

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 2 parameters and an output schema, the description provides the core intent but omits the limit parameter and any usage context (e.g., when to choose this over other get_* tools). It is adequate but lacks detail needed for full autonomous selection.

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

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

The description mentions 'for a topic', covering the required topic parameter, but the optional limit parameter is never mentioned. Since schema description coverage is 0%, the agent receives no guidance on the limit's purpose or its relation to the result set beyond raw schema constraints.

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 ('Read') and resource ('VaultCrux Memory Core import audit history and linked receipt hashes'), and scopes it by 'for a topic'. This clearly distinguishes it from sibling get_* tools such as get_checkpoints or get_contradictions.

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 clearly identifies the context (audit history for a topic) without explicitly naming alternatives or exclusions. The phrasing 'for a topic' gives clear context, but there is no mention of when not to use this tool or which sibling tool to use instead.

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

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

There are no annotations, so the description carries the burden of disclosing behavior. It reveals that the tool returns a graph of relationships, which is useful, but it does not mention potential errors, permissions, whether the decision must exist, or any side effects (though 'Get' implies a read-only operation).

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

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

The description is a single, well-structured sentence that front-loads the main action and resource, then provides clarifying detail. Every word earns its place with no redundancy or unnecessary elaboration.

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 parameter, output schema exists), and the description covers the core purpose and result type. However, it lacks usage guidance, edge-case behavior, and any note about when to choose this over related chain/audit tools, which is a gap given the large sibling set.

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

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

The schema has one parameter, decision_id, with no description in the schema (0% coverage). The description ties it to 'a specific decision', which clarifies its purpose, but it does not provide format requirements or how to obtain the ID. The parameter is self-explanatory given the tool name, so the description adds minimal value beyond the obvious.

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 specifies the verb 'Get' and the resource 'causal chain graph for a specific decision', with additional detail on what the graph shows (decisions, actions, supersessions). This distinguishes it from sibling tools like get_correction_chain or get_decision_context by focusing on the causal chain concept.

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

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

The description implies usage when you have a specific decision and need its causal chain, but it does not explicitly state when to use this tool versus alternatives like get_correction_chain or get_audit_trail. No exclusions or alternative recommendations are provided.

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 that only 'active' entries are returned and describes the content, but it does not mention permissions, error behavior, or any side effects. For a read-only get tool, this is adequate 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 description is a single, tightly written sentence that front-loads the action and resource. 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?

Given a single parameter, a rich output schema exists, and the description provides enough context to understand the tool's purpose and output. It could mention edge cases, but the description is complete for typical usage.

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 clarifies that the result is for a specific agent, indirectly defining the agent_id parameter. However, it doesn't explicitly name the parameter or provide syntax/format details, so it adds only moderate 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 uses a specific verb ('Return') and clearly identifies the resource ('AgentCharacterKernel entries') and scope ('for an agent'). It also specifies the included content (behaviour tuples and sufficiency bands), which distinguishes it from sibling get_* 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 context that this data is 'used by drift checks', implying when this tool would be relevant, but it does not explicitly state alternatives or when not to use it. No direct comparison with sibling tools like assess_character_drift is provided.

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 states the return format ('linked list') and ordering ('reverse chronological'), which is valuable context. However, it does not explicitly confirm non-mutating behavior or describe error outcomes, so it falls short of a perfect score.

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

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

The description is extremely concise: two sentences, front-loaded with the primary action, and every word earns its place. No fluff or repetition.

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

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

Core purpose and use case are well covered, and the output schema exists so return values are documented elsewhere. However, the missing explanation of the 'limit' parameter and lack of any error or edge-case context make it only partially complete for a 2-parameter tool.

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

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

Schema coverage is 0%, so the description must compensate. It implies the meaning of session_id via 'for a session,' but completely ignores the 'limit' parameter, leaving its purpose and interaction unclear. This is a significant 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 'Retrieve' with a clear resource 'decision checkpoints for a session,' and adds distinguishing details like 'linked list' and 'reverse chronological order.' It clearly differentiates from siblings such as get_decision_context or get_audit_trail.

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

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

Provides an explicit use case: 'Use this to resume work from a prior checkpoint after session failure or handoff.' This gives strong situational guidance, but does not explicitly mention when not to use it or name alternative 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?

With no annotations provided, the description carries the transparency burden. It discloses a default of 'active' constraints and the ability to filter, which adds context beyond the schema. However, it does not discuss other behaviors like pagination, authentication, or response structure. It is minimally transparent but not misleading.

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

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

The description is a single, well-structured sentence that conveys the core purpose and key options with 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?

Given the tool's simplicity, the optional filters, and the presence of an output schema, the description is largely complete. It clarifies the default scope and main filter options. A minor ambiguity exists around whether filtering by status overrides the 'active' default, but this is a small gap and does not hinder overall understanding.

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 explains the role of status, type, and team as filters, which maps to constraint_type, status, and team_id. However, it omits the 'limit' parameter and does not clarify the meaning of enum values, leaving some semantic gaps.

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

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

The description uses a specific verb ('List') and clearly identifies the resource ('organisational constraints') with scope ('active'). It also distinguishes from siblings like declare_constraint and update_constraint by focusing on listing/reading rather than creating or modifying constraints.

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

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

The description implies usage context: to list constraints with optional filters. It mentions the filterable dimensions (type, status, team) and implies a default of active constraints. However, it does not explicitly mention alternatives or exclusion cases (e.g., when to use check_constraints instead), so it stops short of a 5.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the tool resolves conflicts by favoring the most recent version and returns groups of artefacts. While it doesn't mention side effects, this is a read operation and the behavior is adequately described.

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

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

The description is three short sentences, front-loaded with the primary action. Every sentence earns its place, providing purpose, behavior, and usage guidance without fluff.

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 an output schema. The description covers the purpose, timing, and the 'most recent wins' heuristic, making it sufficiently complete for an agent to select and invoke 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 schema contains a single 'limit' parameter with no description, and the description does not mention it. Given 0% schema description coverage, the description should have compensated, but it leaves the parameter semantics entirely to the name and min/max constraints.

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 specific verbs ('find', 'returns') and resource ('conflicting information across the user's memory'). It distinguishes itself from siblings by focusing on contradictions and grouping them by topic.

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 says 'Use after gathering evidence for an answer' and explains the scenario when evidence sources disagree. However, it does not name alternatives or mention when not to use, so there is clear context but no exclusions.

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

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

With no annotations, the description carries the full burden. It discloses that the tool returns a full chain with timestamps and implies a read-only trace operation. It doesn't cover edge cases, but for a GET-like tool this 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?

Four concise, front-loaded sentences. Each sentence earns its place: purpose, trigger, return value, and usage rule. No filler or redundancy.

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

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

For a simple tool with an output schema, the description covers purpose, usage, and return well. However, the undocumented decision_id and the misleading example leave a real gap in correct invocation, making it only minimally viable.

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

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

Schema coverage is 0% and the description never defines the decision_id parameter. The example ('Rachel moved to Chicago') refers to a value, not a decision_id, which could mislead the agent into passing the wrong kind of input.

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 ('Trace') and names the resource ('how a fact or decision evolved over time'). It explicitly states the return type ('full version chain with timestamps') and distinguishes itself from siblings like get_causal_chain by focusing on supersession across sessions.

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 when-to-use guidance: call it when you find a value that might be superseded, and ALWAYS for 'current', 'now', or 'most recent' questions. It does not mention when not to use it or name alternatives, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Retrieve' implies a read-only operation, but there is no explicit statement about side effects, required permissions, or pagination behavior. The mention of 'cursor positions' hints at pagination but is not explained.

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 one concise, front-loaded sentence that communicates the action, target, and included fields without redundancy. Every word contributes to the 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 one-parameter retrieval tool with an output schema, the description is adequate but has clear gaps. It does not explain how session_id is used, what 'cursor positions' mean, or how this tool relates to similar sibling tools. The output schema likely covers return structure, but the description could still provide more context for proper selection and 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?

The input schema has no description for session_id (0% coverage), and the tool description does not mention session_id at all. It fails to explain what session_id refers to (e.g., the agent session identifier) or any format requirements beyond the schema's type and minLength. The parameter name is self-explanatory to some extent, but no additional meaning is added.

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

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

The description clearly states a specific action ('Retrieve') and a specific resource ('agent session decisions from the CoreCrux Decision Plane'), and it lists included elements (decision IDs, outcomes, cursor positions). This distinguishes it from sibling tools like get_decisions_on_stale_context or get_checkpoints by focusing on session decisions and cursor positions.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, typical scenarios, or references to sibling tools such as record_decision_context or get_decisions_on_stale_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. It only states the tool 'finds' decisions, with no disclosure about read-only behavior, how staleness is determined, or any side effects. The phrase 'may have been made' hints at inference but 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?

One sentence, front-loaded with the action and scope, no redundant words. Excellent conciseness.

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

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

With one parameter and an output schema present, the tool is simple, but the description lacks context on how to interpret the results or when this tool is relevant. The concept of 'stale memory context' is vague and could use elaboration.

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 sole parameter session_id has zero schema coverage. The description ties it to 'in a session', which adds minimal meaning, but the parameter name is self-explanatory. Since schema coverage is low, the description partially compensates but could be more explicit.

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 ('Find') and resource ('decisions in a session') with a distinctive qualifier ('on stale memory context') that clearly distinguishes this tool from broader decision-centric siblings like get_decision_context or freshness reports.

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

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

The description implies usage when stale context is suspected, but it does not explicitly mention when to avoid this tool or name alternatives (e.g., get_freshness_report, get_decision_context). Guidance is only implicit.

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 behavioral disclosure burden. It transparently lists the types of changes returned (constraints added/updated, knowledge changes, decisions recorded, alerts raised/resolved) and conveys that it is a read-only changelog by nature. It does not mention potential limitations like the 90-day max window, but that is captured in the schema.

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

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

The description is two sentences: the first states the core function and return content, the second gives a direct usage recommendation. Every clause is informative, there is no fluff, and key information is 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 moderate complexity, the description supplies essential context: what it returns, for which domains, and when to use it. Since an output schema exists, the return structure is covered there. The description could have mentioned optional parameters like 'limit' or 'include', but these are well-documented in the schema, so the description remains adequate for selection and invocation.

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

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

The schema provides descriptions for all four parameters, so the baseline is 3. The description adds minimal extra meaning by listing artefact types that map to the 'include' parameter, but this is largely redundant with the schema's enum. No further parameter-level detail is 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 description clearly identifies the tool as a 'cross-artefact-type changelog' that returns changes across constraints, knowledge, decisions, and alerts, which distinguishes it from more specific sibling tools like get_constraints or get_audit_trail. The verb is implied by 'Returns' and the resource is precisely scoped to 'specified domains since a given timestamp.'

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 states the primary usage context: 'Use at session start to learn what changed in your domain since your last session.' This provides clear when-to-use guidance, though it does not explicitly mention when not to use the tool or name alternative sibling 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 behavioral disclosure burden. It does not indicate whether the operation is read-only, whether it supports filtering by status or correction_id, whether pagination applies, or what the response shape is. The minimal description leaves significant behavioral 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?

The description is one sentence, concise, and front-loaded with the action. Every word contributes to the purpose; the status list is directly relevant. No redundant or extraneous content.

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 having an output schema, the tool has no annotations and a very sparse description. It lacks crucial context such as how to filter by status or correction_id, whether the statuses are mutually exclusive, or how the 'limit' parameter behaves. For a read-type tool with optional parameters, this is insufficiently 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 schema has 0% description coverage, so the description must compensate. It does list the allowed statuses, which overlap with the enum in the schema, but it does not explain the 'limit' or 'correction_id' parameters or how they affect the result. Thus it adds marginal value beyond the schema, but not enough.

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 checks the status of submitted corrections and enumerates the possible statuses. It uses a specific verb ('Check') and a specific resource ('status of submitted corrections'), making it distinct from sibling tools like get_correction_chain or submit_correction.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention that it should be used after submitting a correction, nor does it exclude cases like checking a specific correction by ID. The description is purely a statement of function, with no usage context or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses the output categories and the basis (composite confidence and difficulty profile), but does not explicitly state whether the operation is read-only, whether it requires specific setup, or any side effects.

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

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

The description is two sentences, front-loaded with the main purpose and output details, with no unnecessary 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?

Although the output schema exists, the description lacks essential context about how to interpret the escalation levels, the role of each parameter, and when to act on the recommendation. This makes it incomplete for an agent to fully understand the tool's scope and limitations.

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 mentions 'query' and 'composite confidence' (likely query_confidence), but does not explain session_id, current_model, or how the difficulty profile is calculated, leaving the remaining parameters ambiguous.

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 ('Get') and resource ('model routing recommendation'), and explicitly lists the possible output values (none, recommended, required). This distinguishes it from sibling tools like 'escalate_with_context' or 'get_active_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?

No guidance is given on when to use this tool versus alternatives, or any exclusions. The description only explains what the tool does, not the context in which it should be invoked.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explains that topics with stale data may have been superseded by newer conversations, adding interpretive context. However, it does not disclose whether the tool is read-only, how limit/stale_after_days affect results, or any other behavioral traits, so it's adequate but not rich.

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, no redundancy, and front-loaded with the core action. Each sentence contributes essential information: what it does, how to use it, and an interpretive caveat. Extremely 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?

The description covers purpose, usage, and a key interpretation point. With an output schema present, it doesn't need to detail return values. However, it lacks parameter guidance and does not address the overlap with sibling tools like 'memory_freshness_report', leaving some contextual gaps for a complete picture.

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

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

The schema has 0% description coverage for parameters, so the description must compensate. It does not mention 'limit' or 'stale_after_days' at all. The parameter names are somewhat self-explanatory, but without any explanation of how they affect the report, the description fails to bridge the gap left by 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 checks how recent stored knowledge is across topics and returns staleness indicators per topic. It uses a specific verb ('check') and resource ('stored knowledge'), but does not explicitly distinguish itself from the sibling tool 'memory_freshness_report', which likely serves a similar 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?

Explicitly says to use this tool when answering time-sensitive questions to verify evidence isn't outdated. This provides a clear usage context. However, it does not mention when not to use it or provide alternatives, so it stops short of a full 5.

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

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

With no annotations provided, the description carries the full burden. It clearly describes the type of historical knowledge returned (incidents, failures, gotchas, constraints) and gives real-world examples, which is useful. However, it does not explicitly state that the tool is read-only, whether it requires special permissions, or what happens when no incidents are found (e.g., empty result). The concrete examples add value, but core behavioral disclosures beyond 'returns' are minimal.

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

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

The description is three sentences, front-loaded with a purpose question then a direct statement. The second sentence gives usage timing, and the final sentence provides concrete examples ('Docker bind mount traps, Vault agent write patterns, stale dist/ artifacts, port conflicts'). Every sentence earns its place with no redundancy or fluff.

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 an output schema (though not shown), so return-value details are covered elsewhere. The description gives enough context for when to use the tool and what kind of insight it provides. It lacks mention of edge cases (e.g., searching a module with no history) or how it interacts with other context-gathering tools, but overall it is sufficiently complete for a read-oriented lookup 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%, with each parameter (module, limit, days_back, code_paths) having a clear description and example. The tool description does not add additional parameter semantics beyond what the schema provides, 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 opens with a clear verb ('Returns') and identifies the exact resource ('past incidents, deploy failures, gotchas, and active constraints for a module or system'). It distinguishes itself from siblings like get_active_alerts (which would focus on current alerts) and get_constraints (which would list active constraints only) by framing the tool as a historical/tribal knowledge lookup, with concrete example content (Docker bind mount traps, Vault agent patterns).

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: 'Use BEFORE modifying infrastructure code, deploy scripts, or any module with a history of fragility.' This gives a clear temporal and situational trigger. However, it does not explicitly name alternative tools or state when NOT to use this tool, so it stops short of the full 5-point 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 implies a read-only list operation, but does not disclose any side effects, permissions, or return format specifics. The phrase 'gap receipts' is undefined, and there is no mention of how filtering or pagination behaves beyond the schema.

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

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

The description is a single concise sentence that gets to the point quickly. However, it includes an inaccurate reference to 'topic' which detracts from its precision. Despite that, it is appropriately brief 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 the tool has 3 parameters, no required fields, and no schema descriptions, the description is insufficient. It does not define what a 'gap receipt' is, when to use this tool, or how the parameters affect results. With an output schema present, some completeness is provided, but the description alone is not enough to guide an agent effectively, especially with many related sibling tools.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'filterable by topic and recency', but 'topic' does not correspond to any parameter in the schema (only limit, since_days, and gap_subtype). It does not explain limit or since_days, and only partially connects 'coverage + enumeration' to gap_subtype. This adds confusion rather than clarity.

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 listing gap receipts, with a parenthetical defining them as 'coverage + enumeration'. This gives a specific action and resource. However, it does not distinguish from sibling tools like 'assess_coverage' or 'fill_gap', and the mention of 'topic' does not map to any schema parameter.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states what it does without mentioning excluded scenarios or related tools that might be more appropriate. The sibling list includes 'assess_coverage' and 'fill_gap', but no differentiation is made.

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. It does state 'Read-through' and 'Returns', indicating a read-only operation, and lists the returned fields. However, it does not mention potential caveats such as permissions, rate limits, pagination behavior, or data freshness, leaving some behavioral traits undisclosed.

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: the first phrase 'Read-through to PlanCrux task graph' immediately establishes the operation, and the second sentence adds essential detail. Every clause contributes value, with no redundant filler.

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

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

Given the read-only nature, rich output schema, and fully described parameters, the description provides adequate coverage of core behavior and returned fields. It lacks explicit guidance on when to choose this over sibling task-related tools, but overall it is complete enough for a straightforward read operation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds modest context by stating that results are 'filtered by status and priority', but it does not explain the limit parameter or provide any semantics beyond what the schema already offers. This is acceptable but not additive.

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 ('Returns') and specifies the resource ('PlanCrux task graph') and scope ('assigned to or relevant to the calling agent'). It also mentions filtering by status/priority and the included fields (stage progress, blockers, linked artefact counts), which clearly distinguishes it from siblings like get_task_context or get_checkpoints.

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 clear context for when to use the tool: to retrieve tasks relevant to the calling agent, with optional status and priority filters. It does not explicitly name alternative tools or exclusion criteria, but the use case is sufficiently unambiguous for an agent to select it appropriately.

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 transparency burden. It conveys that this is a read operation via 'Retrieve' and describes the return format as 'structured sequences with delegation readiness signals'. However, it does not disclose safety/read-only status explicitly or mention any limitations, permissions, or error conditions, 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 description is two concise sentences. It front-loads the primary action, provides a clarifying parenthetical, lists filters, and states the return type. Every sentence contributes meaningful information with no redundancy.

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

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

The tool is a relatively simple get/filter operation with optional parameters and an output schema, so the description does not need to detail return values. It covers purpose, key filters, and return format. It is slightly incomplete in not describing the operator_id parameter or exhaustive cadence/delegation values, but overall it is adequate for selecting and invoking 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?

Schema description coverage is 0%, so the description must compensate. It mentions 'cadence (daily, weekly, monthly)' and 'delegation status', but the enum values are incomplete (missing quarterly/event_triggered and the delegation_status values). It does not mention the operator_id parameter at all, which is a required input concept for scoping the records.

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 verb 'Retrieve' and the resource 'operating rhythm records for an operator', with an explanatory parenthetical that distinguishes the concept from calendar data. It is specific and differentiates from sibling tools like get_operator_profile or get_signals_feed by focusing on temporal behavioral patterns.

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 clear context on when to use the tool by framing it as capturing actual human behavior 'not what their calendar says'. It also mentions filterability by cadence and delegation status, which suggests use cases, but it does not explicitly name exclusions or 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?

With no annotations, the description carries the burden. It discloses that it returns the latest version of the profile and defaults to the operator linked to the calling agent's passport. It does not explicitly state read-only behavior, but 'Retrieve' implies it, and the versioning detail adds useful behavioral context.

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

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

Two concise sentences that front-load the primary purpose and then add key details. No wasted words; every sentence adds 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?

Given the tool's simplicity (one optional parameter) and the presence of an output schema, the description covers all essential aspects: what is retrieved, specific content fields, versioning, and default behavior. No significant gaps for a read-only profile getter.

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%, so the description must compensate. It does so by explaining the default operator resolution ('Defaults to the operator linked to the calling agent's passport'), which implicitly clarifies the optional operator_id parameter's role in overriding the default. However, it doesn't explicitly describe the parameter's effect when 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 description clearly states the verb ('Retrieve') and specific resource ('the human operator's working context') with enumerated details (role, domain expertise, communication preferences, quality bar, trusted/distrusted sources). It distinguishes itself from sibling tools like get_passport by focusing on the operator profile, not the agent passport.

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

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

The description implies usage by stating what it retrieves, but does not explicitly mention when to use this tool versus alternatives (e.g., get_passport, update_operator_profile). It provides a default behavior nuance but lacks explicit exclusion criteria or alternative tool references.

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

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

With no annotations provided, the description fully discloses important behavioral traits: it recalculates the receipt count on every call and auto-upgrades the tier when thresholds are met. It also mentions the hint for next tier. This is transparent about side effects and goes beyond a simple read operation.

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

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

The description is three sentences long, front-loaded with the core purpose, and every sentence adds value: thresholds, recalculation, auto-upgrade, and hint. No wasted words or redundancy.

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

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

Given that the tool has no parameters, no annotations, and has an output schema (not shown but indicated), the description provides sufficient behavioral detail, including side effects and tier thresholds. It is complete for a simple retrieval tool with side effects.

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

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

The tool has zero parameters, so per the rubric the baseline is 4. The description doesn't need to explain parameter semantics; it instead clarifies the output behavior, which is sufficient.

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: 'Return the calling agent's passport with current reputation tier and receipt count.' It uses a specific verb ('Return') and resource ('passport'), and distinguishes itself from the sibling tool 'issue_passport' by focusing on retrieval of the caller's own passport.

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

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

The description implies when to use this tool (when the calling agent needs its passport, reputation tier, or receipt count), but it does not explicitly mention alternatives or exclusions. No reference is made to sibling tools like 'issue_passport' to clarify 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool returns structured data, is free at all tiers, and serves discovery purposes. It implies a read-only, safe operation but does not explicitly state side-effect-free behavior or what happens if filters are applied. This is adequate but not deeply 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 three sentences, front-loaded with the core purpose, and every sentence adds value: what it returns, why it's useful, and its cost. No redundant or tangential information is present, making it highly concise 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?

The tool has 3 optional parameters and an output schema. The description covers the main purpose, the type of data returned, and cost. It does not explain parameter usage, which is a minor gap, but given the output schema exists, return values do not need to be described. Overall, it is nearly complete for a simple discovery 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%, and the description does not explain the three optional parameters (category, min_trust_tier, max_credit_cost). It mentions 'trust tiers' and 'credit costs' as content of the manifest, but it does not clarify that these parameters likely act as filters or how they should be formatted. The parameter meanings are left to the agent's inference from names, which is insufficient.

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 what the tool does: 'Machine-queryable manifest of all available MemoryCrux tools, required trust tiers, and credit costs.' It uses a specific verb ('Returns') and identifies a unique resource (platform capabilities), distinguishing it from sibling tools that focus on specific data rather than the full tool manifest.

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 clear context for when to use the tool: 'Returns structured data for agent-to-service evaluation without reading documentation.' It also notes it is 'Free (0 credits) at all tiers' implying safe use for discovery. However, it does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden. It implies a read-only status check via 'Get' and 'indicates,' but does not explicitly state that there are no side effects, nor does it explain what 'update pressure' means behaviorally (e.g., real-time vs. cached, thresholds). It is not misleading but lacks depth.

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

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

The description is a single, front-loaded sentence that states the purpose and the specific indication ('whether knowledge bases are under update pressure'). It is concise with no redundancy or filler.

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

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

For a zero-parameter status tool, the description adequately explains what it does and what it indicates. The presence of an output schema covers return-value details. A minor gap is the lack of context on why 'pressure' matters (e.g., impact on updates), but this is not critical for a simple status retrieval.

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 does not need to explain parameter semantics, and no ambiguity exists. The input schema confirms no properties, so nothing is missing.

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: 'Get Engine knowledge pressure status for the tenant' with a specific resource ('knowledge bases') and a verb ('Get'). It distinguishes from sibling tools by focusing on 'pressure' rather than freshness, enrichment, or alerts. However, the term 'pressure' is only vaguely defined as 'under update pressure,' leaving some ambiguity about the exact metric.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions. With many sibling get_* tools, the lack of usage direction is a notable gap.

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

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

No annotations are provided, so the description carries the burden of explaining behavior. It goes beyond mere retrieval by disclosing ranking logic ('ranked by risk-if-missed') and content priorities ('Constraints and alerts rank above general knowledge'). This gives a useful sense of how the tool behaves. However, it does not explain token budget semantics or whether the call is strictly non-mutating, leaving some behavioral 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 compact and front-loaded. The core purpose is stated in the first sentence, followed by one sentence on ranking logic and one on usage context and sibling differentiation. Every sentence contributes meaning with 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?

The tool has three parameters, no annotations, and an output schema that is not shown but known to exist. The description adequately covers when and how to use it, distinguishes it from sibling tools, and gives behavioral context. However, the lack of explanation for two parameters (token_budget and priority_signal) and the absence of annotation-based safety cues leave some completeness 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 explains the role of task_description ('shaped by your task description') and hints at prioritization, but it does not explain the token_budget parameter (e.g., how it is used, what happens when exceeded) or how priority_signal alters the ranking. The enum values are self-evident from their names, but overall parameter semantics remain incomplete.

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 verb-noun pair ('Task-scoped context briefing') and explains the resource and behavior: 'Returns a prioritised context payload shaped by your task description, ranked by risk-if-missed.' It also explicitly distinguishes itself from the sibling tool query_memory, so there is no ambiguity about what it does.

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

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

The description explicitly tells the agent when to use this tool: 'Use at the START of reasoning about a question to get the system's best assessment of what's relevant.' It also names the alternative, query_memory, and explains how they complement each other: 'this gives breadth, query_memory gives depth.' This provides clear guidance on usage 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?

With no annotations provided, the description carries full burden and delivers: it discloses the dossiers are pre-synthesized, the search ranking mechanism (BM25-ish), the optional type_filter behavior, the chronological list mode, and the important feature-flag behavior yielding an empty list without error. This is comprehensive 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 dense but well-structured: it opens with a clear purpose, then usage context, then mode specifics, and finally a behavioral caveat. Every sentence contributes unique value, and no words are wasted.

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

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

Given the tool's complexity (two modes, four parameters, feature flag behavior) and the presence of an output schema, the description covers all critical usage aspects: what it returns, how modes differ, ranking details, and edge-case behavior. It is complete without being bloated.

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 adds meaning for mode (search/list), query (BM25-ish ranking over summary+purpose), and type_filter (optional). However, the 'limit' parameter is not mentioned in the description at all, leaving a gap. Overall, it provides strong context for most parameters but not all.

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

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

The description clearly states the tool retrieves pre-synthesized per-session memory dossiers with typed metadata, distinguishing it from sibling tools that fetch raw memory or other session data. The verb 'Retrieve' and the specific resource 'per-session memory dossiers' make the purpose 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 states the intended use case ('multi-session or preference-style questions where stitching across conversations is the bottleneck') and describes the two modes. Although it doesn't name alternative tools, the context is clear enough to guide selection. Lacks explicit 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 provided, the description carries the full burden of behavioral disclosure. It implies a read operation but gives no details about pagination, result size, filtering behavior, or any side effects. The phrase 'for the tenant' adds scoping context but does not reveal behavioral traits beyond the basic action.

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

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

The description is a single, front-loaded sentence with no fluff or repetition. It is concise and easy to parse, though it may be too terse given the tool's parameters and lack of annotations; however, that is more a completeness concern than a conciseness issue.

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, an output schema exists but is not explained, and two parameters have zero schema descriptions, the description is insufficiently complete. It lacks context on what signals are included, how limit/since affect results, and any operational considerations, so it only barely meets minimum viability.

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 mention the 'limit' or 'since' parameters at all. Since the schema only provides types and constraints, the description should explain what these parameters control but fails to do so, leaving the agent without meaningful 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 gets the signals feed for the tenant from the WebCrux platform, using a specific verb and resource. However, it does not distinguish this from sibling tools like get_active_alerts or get_freshness_report, which could be confused with a signals feed.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are any exclusions or prerequisites mentioned. The description only states what the tool does, not when or why to choose 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?

With no annotations, the description carries the burden. It adds useful context about assembling from PlanCrux and MemoryCrux and lists what is included, but it does not disclose error handling, missing-task behavior, or performance characteristics.

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

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

Two sentences, front-loaded with the main purpose, and the second sentence adds source context. 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?

For a read tool with an output schema, the description enumerates all major data categories returned, and clarifies the data sources. It could mention usage conditions, but overall it gives a complete picture for an agent to decide.

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

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

The single parameter task_id is already described in the schema at 100% coverage, so the description adds no additional semantic value beyond confirming it refers to PlanCrux IDs or titles.

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 provides the full task context, enumerating the specific components (task metadata, stages, blockers, artefacts, logs, master plan version). It distinguishes itself from narrower sibling get_* tools by explicitly being the comprehensive aggregator.

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

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

The description implies this is the go-to tool for a complete picture of a task, but it does not explicitly state when to use it over alternatives or provide exclusions. Given many sibling tools exist, this lacks clear usage differentiation.

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 states a read operation ('Get') but does not explain any side effects, permissions required, return format, pagination (limit), or the precise meaning of 'at an optional timestamp' (e.g., latest as of that time). This is a significant gap for a tool with no annotations.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It efficiently conveys the core action and key qualifier (optional timestamp).

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 having an output schema and only 3 parameters, the description is too minimal to be fully complete. It lacks parameter semantics for 'limit', clear usage guidance, and behavioral details. The ambiguity around 'latest' vs 'limit' further reduces completeness. It is adequate for a simple get but leaves important 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 explains 'topic' and 'timestamp' implicitly ('for a VaultCrux Memory Core topic at an optional timestamp'), but the 'limit' parameter is entirely undiscussed. Furthermore, 'the latest versioned snapshot' (singular) conflicts with a 'limit' parameter (max 500), suggesting the snapshot might be plural or paginated—creating 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 clearly states the action ('Get') and the specific resource ('latest versioned snapshot for a VaultCrux Memory Core topic'), which distinguishes it from sibling tools like compare_versions and get_audit_trail. However, it does not explicitly name alternatives or contrast with them, so it falls short of a perfect 5.

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

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

There is no guidance on when to use this tool versus alternatives, nor any exclusions or conditions. The optional timestamp hints at a use case, but no explicit context or comparison to sibling tools is provided.

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 disclosing behavior. It details the internal server-side process (intent detection, entity index query, timeline building, memory retrieval, context expansion, aggregation, answerability assessment) and enumerates the response components. It does not explicitly state whether the tool is read-only or has side effects, but the 'investigation' nature and absence of mutation language strongly imply read-only 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 long but well-structured: it opens with a clear summary, then uses a numbered list to enumerate the 8 internal steps, followed by usage guidance and return-value summary. Each sentence contributes meaning, though the 8-step list could be condensed 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?

Despite the tool's complexity (composite with multiple internal processes), the description covers purpose, usage, behavior, and output components. It does not explain optional parameter semantics or potential caveats/latency, but the overall richness is high, especially given the presence of an output schema.

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

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

Schema description coverage is 0%, and the description only says 'Pass a question'—explaining the required parameter but entirely omitting the optional 'question_date' and 'scoring_profile' parameters. The enum values for scoring_profile are self-explanatory, but the description fails to explain when or how to use them, leaving a significant semantic 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 states the tool is a composite server-side investigation tool and enumerates 8 specific steps it performs, distinguishing it from individual sibling tools like build_timeline, query_memory, and assess_answerability. The verb 'investigate' and resource 'question' are 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?

Explicitly instructs to use as the FIRST tool for any non-trivial question, positioning it as a full replacement for 4-6 individual tool calls. It does not name specific alternative tools or state when not to use it, but the 'non-trivial' qualifier implies a clear 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals important traits: idempotency ('calling twice returns the existing passport'), storage mechanism ('BLAKE3-hashed fact'), and a prerequisite ('Required before sync operations'). It does not mention potential side effects or error behaviors, but these are mitigated by idempotency and the presence of an output schema.

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

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

The description is concise and front-loaded, with three sentences covering purpose, storage, tiers, idempotency, and usage prerequisite. Every sentence adds value, though the tier list could be seen as a detail but it is relevant to the reputation system. Slightly longer than necessary but still efficient.

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

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

Given the tool has an output schema, return values do not need to be explained. The description covers the core functionality, storage, idempotency, and usage context. It lacks explicit error scenarios or permission requirements, but the low parameter count and simple behavior make it sufficiently complete for an agent to select and 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?

The schema has only one parameter, sponsor_id, with no description (0% coverage). The description mentions 'sponsor lineage', which hints that sponsor_id is the ID of the sponsor, but it does not explicitly explain the parameter's role or format. It adds some meaning but could be more direct in mapping sponsor_id to the lineage concept.

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 with a specific verb 'Issue' and resource 'agent passport', and elaborates on the components: identity, sponsor lineage, and 5-tier reputation system. It differentiates from the sibling tool 'get_passport' which is for reading, and the mention of 'Required before sync operations' ties it to sync 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 description explicitly states when to use this tool: 'Required before sync operations.' This gives clear context for deployment. It does not explicitly name alternatives or exclusion scenarios, but the sibling list and the read-vs-write distinction implicitly cover that. The idempotency note also informs that repeated calls are safe.

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 explicitly states what is returned (service IDs, display names, allowed methods/paths, rate limit state) and what is not returned (credentials or credential references). This is meaningful beyond the schema and sets appropriate expectations for a read-only listing operation.

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

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

The description is two sentences that front-load the purpose, then list return contents and an important exclusion. Every word earns its place, with no redundancy or fluff.

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 low complexity (one optional parameter) and an output schema is present. The description adequately explains what the tool does, what it returns, and a key limitation, making it complete 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?

Schema coverage is 100% since the only parameter 'status' has its own schema description ('Filter by service status'). The tool description adds no additional parameter context beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses the specific verb 'List' with the resource 'registered external services' and adds the scoping phrase 'available to the calling agent.' This clearly distinguishes the tool from siblings like register_external_service and request_credentialed_call.

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 clear context (list services available to the agent) but does not explicitly mention when to use this tool versus alternatives or any exclusions. Since sibling tools such as register_external_service or request_credentialed_call exist, additional guidance would be helpful, but the purpose is implied well enough.

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 mentions that the output includes freshness metadata, but it does not state whether the operation is read-only, any permission requirements, pagination behavior, or effects on data. For a list tool, this is a notable 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 a single, well-structured sentence that immediately conveys the action and subject. There is no textual fluff; every word contributes meaning.

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