Neotic

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

With no annotations, the description carries the full burden. It reveals that the tool makes a selection based on EVC but does not disclose side effects, state changes, required context, or what the output represents. For a tool that might influence compute resource allocation, 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?

A single front-loaded sentence with a useful label ('Adaptive compute budgeting:') and minimal waste. It loses a point for relying on unexplained acronyms within that sentence.

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 a required nested object parameter, 0% schema coverage, and no annotations, the description is far too thin. Even though an output schema exists, the agent lacks enough context about inputs and criteria to 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 description coverage is 0%, and the description does not compensate. It never mentions 'task_structure', 'stakes', or how they map to compute tier or timeout. The only conceptual hint, 'EVC', does not correspond to any schema parameter, leaving the agent to guess parameter meaning.

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

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

States a concrete behavior: 'select compute tier ... and timeout based on EVC,' which is a clear verb+resource distinct from the many sibling cognitive tools. However, the meaning of 'EVC' is unexplained jargon, and 'Fast Path to Deep Deliberation' is evocative but not formally defined.

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

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

No guidance on when to use this tool versus alternatives. It implies a compute-budgeting context but never states conditions, exclusions, or sibling trade-offs, which is significant given the large sibling set.

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

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

With no annotations, the description must disclose side effects, state changes, or whether this tool returns a recommendation versus actually allocating resources. It only says 'select', leaving the mutation/read-only nature ambiguous, and EVC is not defined.

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

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

The description is a single compact sentence with no filler, and the main verb/action is front-loaded. It loses a point only because the undefined EVC term and missing parameter references make it dense rather than self-contained.

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

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

An output schema exists, so return values are likely covered, but the tool has a required opaque object parameter, no annotations, and no explanation of how EVC relates to task structure or stakes. This is enough to state the tool's purpose but not enough for an agent 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%, yet the description never mentions task_structure or stakes, the two parameters. It does not explain what EVC means, what shape task_structure should take, or what stakes values are valid, so an agent cannot populate the required 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 states a specific action - selecting a compute tier and timeout - and a clear resource (compute budget). 'Adaptive compute budgeting' gives the tool an identifiable role among siblings, though it does not explicitly name alternatives or explain the EVC acronym.

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

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

No when-to-use or when-not-to-use guidance is provided. The phrase 'Adaptive compute budgeting' implies a use case, but there are no prerequisites, exclusions, or references to sibling tools such as cognitive.execute_task or cognitive.tree_search.

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, yet it only says what the tool does, not whether it mutates state, requires pre-existing task structures, records experiences, or has side effects. Mentioning the SME algorithm adds slight specificity but does not compensate for these 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?

A single 10-word sentence with no wasted words, front-loaded with the verb 'Transfer'. It is efficient, though the 'via Structure-Mapping Engine (SME)' clause is a mechanism detail that could arguably be traded for more operationally useful information.

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

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

For a tool with zero annotations and zero parameter descriptions, a single sentence is inadequate. It omits prerequisites (must source and target structures already exist?), side effects, and how this connects to sibling tools like report_transfer. The presence of an output schema covers return values, but the operational context remains thin.

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 undocumented parameters, but it only loosely maps 'domains' to the two structure IDs and never explains strategy_id or its null default. The parameter names are self-evident, but the description adds almost no semantic value beyond them.

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

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

The description states a specific verb and resource ('Transfer structural strategies across disparate domains') and names the mechanism (Structure-Mapping Engine), signaling a distinct operation from siblings like report_transfer or synthesize_program. However, it does not explicitly differentiate itself from the many related cognitive.* tools, and 'structural strategies' is somewhat jargon-heavy.

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 siblings like report_transfer, compose_strategies, or synthesize_program. The only weak implication is 'across disparate domains', which hints that the tool is for cross-domain cases but provides no exclusions, prerequisites, or ordering relative to other cognitive operations.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions using SME but does not explain what happens during transfer (e.g., whether it modifies strategies, creates new ones, or returns a report). It also doesn't mention any prerequisites, side effects, or required permissions. This is a significant gap for a tool that potentially mutates state.

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

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

The description is extremely concise, a single sentence with no fluff. It front-loads the core purpose and mechanism. It earns its place by being direct and informative, even if it lacks detail in other areas.

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 (cognitive analogical transfer via SME) and the lack of annotations, the description is insufficient. It does not explain the return value (output schema exists but description doesn't clarify), nor does it cover edge cases like what happens if the strategy_id is null. The agent lacks critical information about the transfer process and expected results.

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 only implies source and target structures but does not explain what each parameter means or how they are used. The optional strategy_id is completely unexplained, potentially causing agents to misuse it. The description fails to clarify parameter formats or selection criteria.

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 (transfer) and the resource (structural strategies) and specifies the mechanism (via Structure-Mapping Engine). It distinguishes itself from siblings like cognitive.compose_strategies by focusing on cross-domain transfer rather than composition. However, it could be more specific about the nature of the transfer (e.g., from one task structure to another) but the schema already hints at source and target.

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 explicit guidance on when to use this tool versus alternatives. It implies usage for cross-domain strategy transfer but does not contrast with other tools like cognitive.report_transfer or cognitive.record_experience. An agent may infer from the name and sibling list, but clear exclusions would improve this.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It clearly states the core behavior—auditing speech acts and detecting deception—but it does not disclose any assumptions, limitations, confidence levels, or processing caveats beyond that.

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

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

The description is a single, front-loaded sentence that starts with the domain ('Pragmatic communication') and immediately states the action and target. Every word earns its place and there is 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?

Given seven parameters, no annotations, and 0% schema description coverage, the description is too sparse for reliable invocation. The output schema exists, so return values are less of a concern, but the roles of the optional parameters and the expected content format are not addressed at all.

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

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

Schema description coverage is 0%, so the description must compensate for the seven parameters. It only hints at 'speech acts' (likely mapping to act_type) and 'deception' (possibly claims), while leaving content, sender_id, recipient_id, context_goals, and speaker_beliefs completely unexplained.

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 ('audit') tied to a clear resource ('speech acts against Gricean maxims') and adds the distinct function 'detect deception.' This clearly separates it from the many sibling cognitive tools, none of which mention Gricean maxims or deception detection.

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 intended use is implied: an agent should call this when it needs to audit communication pragmatically or detect deception. However, the description does not explicitly state when to prefer this tool over siblings like theory_of_mind or resolve_intent, nor does it give any 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 and does convey the core behavior: auditing content against Gricean maxims and flagging deception. However, it discloses no behavioral context such as whether the tool is read-only, how it handles internal consistency among claims/beliefs/goals, or what a deception determination means.

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 compact sentence with useful specifics (Gricean maxims, deception) and little waste. It could be slightly more structured by leading with a verb phrase, but it earns its place.

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

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

The core call (content) is obvious and an output schema exists, but with no annotations and no parameter guidance the description leaves room for confusion about optional inputs that shape the analysis. It is minimally adequate for selecting the tool but not fully sufficient for correct invocation in nuanced 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%, and the description does not map any of the seven parameters to their roles, leaving optional but contextually important fields like claims, context_goals, speaker_beliefs, and act_type to be inferred from names alone. This does not meet the compensation burden for a low-coverage 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 identifies a specific operation ('audit speech acts') against named Gricean maxims and adds deception detection, so an agent can recognize the tool's core function. It does not explicitly distinguish itself from the adjacent sibling cognitive.analyze_communication, and the leading 'Pragmatic communication:' is more label than verb-led statement.

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 text explains when to choose this tool over cognitive.theory_of_mind, cognitive.assess_competence, or the near-duplicate cognitive.analyze_communication. The only guidance is implied by the phrase 'Pragmatic communication'; there are no exclusions, prerequisites, or alternative routing.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It reveals the theoretical mechanism but does not disclose side effects, state changes, mutation, permission requirements, or what Ulysses pre-commitment actually does operationally. The output schema covers return values, not behavior.

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

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

The description is a single sentence with no filler. It front-loads the core action and immediately provides the distinguishing method. Every phrase contributes useful information.

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

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

There is an output schema, so return values need not be explained. However, with six parameters, nested objects, no annotations, and zero parameter-level documentation, the description leaves audit_action_switch and register_commitment opaque and the option object shapes unspecified. An agent lacks enough context to invoke this tool confidently.

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

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

Schema description coverage is 0%, and the description does not explain k_hyperbolic, gamma_exponential, audit_action_switch, register_commitment, or the expected structure of the two nested option objects. The reference to hyperbolic vs exponential discounting weakly hints at the numeric parameters, but this is insufficient for correct parameterization.

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

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

States a specific action ('arbitrate') and a specific resource ('short vs long term payoffs'), and names the method: hyperbolic vs exponential discounting plus Ulysses pre-commitment contracts. This clearly differentiates it from sibling tools like cognitive.compose_strategies or cognitive.resolve_intent.

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 the tool: when there is a tradeoff between immediate and delayed payoffs and commitment is needed. However, it does not provide explicit when-to-use or when-not-to-use guidance, nor does it 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It hints at a theoretical mechanism but does not state whether the tool is read-only, whether it registers commitments or audits switches as side effects, or what observable behavior follows invocation. The presence of register_commitment and audit_action_switch parameters suggests possible write behavior that is left 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 efficient sentence with the primary task front-loaded before the method. It wastes no words, though the dense jargon reduces immediate readability.

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

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

For a six-parameter tool with no annotations and zero schema description coverage, one sentence is not complete. The agent cannot infer expected input shapes, side effects, commitment behavior, or how the arbitration result is returned. The output schema helps but does not offset the missing guidance.

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 gives rough context for short_term_option and long_term_option and vaguely maps 'hyperbolic vs exponential' to k_hyperbolic and gamma_exponential, but it says nothing about audit_action_switch or register_commitment and offers no concrete semantics for the nested objects. This is insufficient for six parameters with zero schema descriptions.

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

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

The description names a specific verb ('arbitrate'), a clear resource ('short vs long term payoffs'), and a distinctive method ('hyperbolic vs exponential discounting and Ulysses pre-commitment contracts'). It is specific enough to distinguish the tool's intent from most siblings, though it relies on jargon and does not explicitly contrast with cognitive.arbitrate_temporal_objectives.

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

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

The description implies the tool is for temporal trade-off decisions but provides no guidance on when to choose it over alternatives, no preconditions, and no exclusions. With a large sibling list, an agent gets little help selecting this tool correctly.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. 'Track calibration' hints at possible state tracking or updates, but it is unclear whether this tool mutates calibration state, only evaluates, or has side effects. No safety or persistence behavior is disclosed.

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

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

A single, front-loaded sentence with no filler. The core purpose and classification categories are stated immediately, and the wording is compact while conveying meaningful detail.

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, the definition is incomplete for correct invocation: parameter semantics are missing, behavioral side effects are ambiguous, and usage context versus sibling tools is absent. For a metacognitive tool with zero annotations and zero schema descriptions, the description does too little to make the tool safely and correctly callable.

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 gives conceptual context for task classification but never explains the meaning or expected shape of 'task_structure' or the role of 'actual_outcome' in calibration. The agent is left to guess how to populate either parameter.

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

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

The description uses a specific verb ('classify') with a clear resource ('task') and names the exact output categories (KNOWN, KNOWN_UNKNOWN, UNKNOWN_UNKNOWN). It implies a distinct epistemic-assessment role among the cognitive tools, though it does not explicitly contrast itself with siblings like identify_task or parse_task.

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 'Epistemic boundary awareness' implies use when the agent needs to determine whether a task is known, known-unknown, or out-of-distribution. However, there is no explicit guidance on when to prefer this tool over related siblings, nor any stated exclusions or prerequisites.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It is clear that the tool likely updates internal state (tracking calibration) and performs analysis, but it does not specify if it mutates state, requires permissions, or the specifics of its output. It is somewhat transparent but lacks depth on behavioral 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 concise—a single sentence that front-loads the core purpose. It is not verbose or redundant, and the key action is immediate. However, it could benefit from a brief elaboration on calibration tracking, but it remains efficient.

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

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

The tool is conceptually complex (classifying task types and tracking calibration), and the output schema exists, so return format may be covered. However, the description lacks crucial context: what types of inputs are expected, what the tool returns (though output schema may help), and how it interacts with other tools. The absence of parameter explanations and usage guidance leaves significant 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 schema provides no explanations for `task_structure` or `actual_outcome`. The description does not elaborate on these parameters either, only mentioning 'task' generically. This is a significant gap given both parameters are undocumented, and the description fails to 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 identifies the tool's purpose: classifying tasks into epistemic categories (KNOWN, KNOWN_UNKNOWN, UNKNOWN_UNKNOWN) and tracking calibration. It uses specific verbs and a clear resource ('task') and provides a distinct functionality from siblings, though it doesn't explicitly name alternatives.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It implies it is for assessing competence and epistemic awareness, but does not mention conditions, exclusions, or alternative tools. An agent would have to infer usage from the name and description alone.

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

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

With no annotations, the description carries the behavioral burden. It discloses a non-obvious behavior: it rejects claims like 'optimal', 'verified', or 'feasible' when their evidence dependencies are incomplete. It does not state whether the graph is mutated or if this is purely read-only, but 'audit' implies non-mutating and the output schema covers return details.

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

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

The description is compact and well-structured: the first sentence states purpose and timing, the second states the rejection behavior. Every sentence earns its place, and there is no redundant or filler 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?

For a single-parameter audit tool, the description provides the core needed context: what it audits, when to invoke it, and what it rejects. The output schema covers return values. It lacks explicit side-effect disclosure and direct sibling differentiation, but these are minor given the low complexity.

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

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

Schema description coverage is 0%, so the description must compensate. However, it only says 'for a task' and never explains what task_structure_id refers to, its format, or how to obtain it. The parameter title provides some meaning, but the description adds almost no semantic value beyond that.

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

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

The description uses a specific verb ('Audit'), identifies the resource ('the evidence graph for a task'), and states the operational context ('before issuing final answers'). It also distinguishes this from sibling tools like build_evidence_graph by making clear this is a verification/rejection step, not a construction step.

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 states when to use the tool: before issuing final answers. It does not explicitly name alternatives or exclusions, but the context is strong enough that an agent can infer this is the pre-submission audit step rather than a graph-building or claim-evaluation tool.

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

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

With no annotations provided, the description carries the full disclosure burden. It reveals a key behavior—rejecting claims based on incomplete evidence dependencies—but does not state whether the operation is read-only, has side effects, requires specific permissions, or what happens after rejection. 'Audit' implies inspection, but the rejection behavior is presented without clarifying its consequences.

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 front-loads the verb, resource, and timing, and the second provides concrete rejection examples. Every clause earns its place, and there is no redundant or filler 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?

The tool is simple (one required parameter) and has an output schema, so the description need not detail return values. However, it leaves notable gaps: the meaning of task_structure_id is not explained, side effects are not disclosed, and the relationship to build_evidence_graph is not mentioned. The description covers the core purpose but is incomplete for a fully informed agent.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It only says 'for a task', which loosely maps to task_structure_id, but does not explain what a task_structure_id is, how to obtain it, or how it relates to the evidence graph. This is insufficient compensation for an undocumented 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 identifies the action ('Audit'), the resource ('the evidence graph for a task'), and the timing ('before issuing final answers'). It also specifies concrete rejection behavior with examples ('optimal', 'verified', 'feasible'), which distinguishes it from siblings like build_evidence_graph and evaluate_claim_evidence.

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

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

The description gives a clear usage context: run this tool before issuing final answers, and reject claims with incomplete evidence dependencies. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of the highest level of guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Build or update.' It does not clarify whether the graph is overwritten, whether existing data is preserved, whether task_structure_id must already exist, or what side effects updating may have.

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

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

The description is a single focused sentence with no filler. It is reasonably front-loaded and readable, though the jargon 'Evidence-Carrying Cognitive Graph' is not unpacked.

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, no annotations, and no parameter descriptions, the definition is too sparse. It lacks usage context, parameter semantics for claims, and behavioral details around update semantics, making it hard for an agent to invoke correctly 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?

Schema description coverage is 0%, so the description must compensate. It names 'task structure' and 'solution trace,' which loosely map to task_structure_id and solution_trace, but it never mentions the claims parameter, and all three parameters remain semantically underdescribed.

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 ('Build or update') with a clear resource ('Evidence-Carrying Cognitive Graph') and mentions the relevant inputs ('task structure and solution trace'). It distinguishes the action from auditing or evaluating evidence graphs, though it does not explicitly name a sibling alternative.

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

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

No guidance is given about when to use this tool versus alternatives like audit_evidence_graph or evaluate_claim_evidence. The description implies a use case but provides no conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates that the tool can both create and update a graph, but does not explain what happens on update, whether existing data is replaced, what claims are expected, or whether the operation has side effects. The behavior is too opaque for a state-changing graph 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 a single, front-loaded sentence with no filler or repetition. It wastes no words and places the verb and object first. However, its brevity comes at the cost of missing behavioral and parameter detail, so it is concise but not complete.

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

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

With no annotations, 0% parameter coverage, and a graph-building operation, the description is too sparse to fully support correct invocation. It does not explain when to build versus audit, how claims and solution_trace relate to the graph, or update semantics. The presence of an output schema reduces the need to describe return values, but the input and decision context remain incomplete.

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

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

Schema description coverage is 0%, so parameter meaning must come entirely from the description. The description references task_structure_id and solution_trace by role, but it omits the 'claims' parameter entirely and gives no detail about required structure or format for any parameter. This leaves a required parameter and two optional inputs semantically under-specified.

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 ('Build or update') and a specific resource ('Evidence-Carrying Cognitive Graph'), and identifies the inputs ('task structure and solution trace'). This is clear enough for an agent to recognize the tool's core function, though it does not explicitly differentiate from sibling tools like cognitive.audit_evidence_graph or cognitive.evaluate_claim_evidence.

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 no guidance on when to use this tool versus an alternative. It does not mention audit_evidence_graph, build_evidence_graph, or evaluate_claim_evidence, nor does it state conditions, prerequisites, or exclusions. Usage context must be inferred entirely from the tool name and description.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does add methodological context by mentioning do-calculus and backdoor adjustment, but it does not state assumptions such as requiring a valid DAG or that all confounders are observed, nor whether the adjustment set is user-supplied or automatically found.

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

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

A single sentence with no filler. The core purpose and method are front-loaded, and the parenthetical 'do-calculus' adds precision without extra bulk.

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 four required parameters, no parameter descriptions, and no annotations, one sentence about method is insufficient. Key information about graph assumptions, input format, and when to select this tool over siblings is missing, though the presence of an output schema mitigates 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 does not mention edges, treatment, outcome, or observations. The causal terminology partly maps to the parameter names, but the description fails to explain edge format, observation shape, or how treatment and outcome are expected to be specified.

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

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

The description names a specific operation: distinguishing causal effects from spurious correlation, and adds the method (backdoor adjustment/do-calculus). This clearly separates it from broad siblings like cognitive.infer or cognitive.execute_task.

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 use case is implied: when you have a causal graph and observational data and want an effect estimate adjusted for confounding. However, it never states when not to use this tool or names alternative tools for related but different tasks.

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

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

With no annotations, the description must carry the behavioral burden; it conveys a read-only style statistical analysis and the adjustment strategy. However, it does not state what the tool returns as its 'distinction,' how it treats invalid graphs, or any failure behavior.

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

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

One tightly written sentence with no filler, and the core distinction is front-loaded. The dense jargon (do-calculus, backdoor adjustment) makes it slightly less approachable but not padded.

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

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

For a four-parameter tool with no annotations, this is thin: the schema names are self-explanatory, but without guidance on edge encoding, observation shape, or expected result, an agent cannot reliably construct a valid call. An output schema exists, so return-value detail is not the main gap.

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

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

Schema coverage is 0%, so the description must compensate for undocumented parameters. It indirectly aligns edges/treatment/outcome/observations with a backdoor-adjustment analysis but never explains edge direction conventions, observation format, or how the four inputs relate.

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

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

Names a specific analytic goal (separating causal effects from spurious correlation) and a concrete method (backdoor adjustment), which distinguishes it from general causal-analysis siblings. It is not a fully operational verb like 'estimate' or 'compute', but it is clearly recognizable.

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 method phrase implies use for observational causal inference where confounding must be controlled via backdoor adjustment. It does not name alternatives or say when not to use it, leaving routing among cognitive.causal_analysis and similar siblings to the agent.

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

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

No annotations are provided, so the description carries the full burden. 'Compile into' implies a computational transformation, but the description does not disclose whether this is read-only, whether it requires a valid lattice, what happens on invalid input, or what outputs are returned.

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

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

The description is a single tight sentence, defines the DCL acronym, and front-loads the core transformation. It is efficient, though somewhat under-specified given the tool's parameter 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?

With no annotations and opaque optional parameters, the description is insufficient for an agent to know when to call this tool, what input structure is expected, or how the DCL is represented. The output schema may cover return values, but selection and parameter usage remain unexplained.

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

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

Schema description coverage is 0% and the description references none of the six parameters. It does not map task_data, initial_state, goal_conditions, or max_rate_of_change to the DCL compilation process, leaving the agent unable to determine how to populate the inputs.

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 ('Compile') and resource ('Dynamic Constraint Lattice') and names three concrete output categories: algebraic boundaries, conservation laws, and reachability cones. It is not a tautology, though it does not explicitly differentiate from related lattice-focused siblings.

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

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

There is no guidance on when to use this tool versus alternatives, no stated prerequisites, and no exclusions. Given the large sibling set, the agent receives no selection criteria beyond the tool's own 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 carries the full burden. It states that the tool compiles a lattice into mathematical constructs, but does not disclose whether this is a pure computation, whether it mutates state, whether it has side effects, or what behavior occurs on invalid inputs.

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 or repetition. It front-loads the core action and result, though the acronym 'DCL' is introduced and then unused, and the sentence is somewhat dense with jargon.

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

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

With six parameters, zero schema descriptions, and no annotations, this one-sentence description is not sufficient for an agent to invoke the tool confidently. The existence of an output schema helps for return values, but the description omits any explanation of input semantics and usage context.

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

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

Schema description coverage is 0% and the description mentions none of the six parameters. The property names and titles provide only minimal hints; the description does not explain how task_data, step_budget, initial_state, goal_conditions, task_structure_id, or max_rate_of_change relate to the lattice compilation.

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 ('Compile') and identifies both the input resource ('Dynamic Constraint Lattice') and the outputs ('algebraic boundaries, conservation laws, and reachability cones'). This makes the tool's function clear, though it does not explicitly distinguish it from the similarly named sibling cognitive.compile_invariant_lattice.

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 about when to use this tool versus alternatives such as cognitive.compile_invariant_lattice or cognitive.verify_lattice_transition. There are no conditions, exclusions, or prerequisite scenarios described.

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 hints at behavioral aspects (explicit stage transitions, end-to-end verification) but does not disclose side effects, prerequisites, reversibility, or required permissions. For a synthesis tool this is a meaningful 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 two sentences, front-loaded with the core purpose. It is efficient and avoids redundancies, though the second sentence adds an example without delving into detail.

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 (synthesizing a composite pipeline) and zero schema coverage, the description is insufficient. It does not explain what constitutes a primitive strategy ID, how stages are defined, or any constraints on inputs. The presence of an output schema partially relieves the need to describe returns, but input semantics remain under-specified.

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 chaining skills and composite StrategyIR but does not explain what strategy_ids should contain, how composite_name is used, or the role of the optional description parameter. Only generic context 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 states a specific action ('synthesize a composite multi-stage StrategyIR from primitive strategies') and identifies the resource (strategies). It distinguishes from siblings like propose_strategy or execute_task by focusing on composition, though it doesn't name alternatives explicitly.

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

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

It implies usage when chaining multiple specialized skills is needed, and mentions explicit stage transitions and verification. However, it does not state when not to use it or name alternative tools, leaving the decision partially to inference.

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

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

No annotations are provided so the description fully bears the transparency burden. It discloses the pipeline nature ('chains multiple specialized skills', 'explicit stage transitions', 'end-to-end verification'), giving some process insight. However, it does not state side effects, whether it persists the composite, or any authorization requirements, leaving important behavioral aspects 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 two sentences, front-loads the core purpose, and includes a concrete example that aids understanding. It is efficient without unnecessary verbosity, though it could add a bit more parameter guidance without harming 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?

Provides a strong high-level overview, and the output schema covers return format. However, it lacks explicit parameter-level details, such as what constitutes a primitive strategy ID, whether strategies must already exist, and the role of the description field. Without annotations, these gaps reduce completeness for reliable invocation.

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

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

Schema coverage is 0% and the description does not explicitly map its three parameters. It hints that strategy_ids are primitive strategies and composite_name is the composite's name via context, but the description parameter is entirely unaddressed. This minimal compensation leaves significant ambiguity for agents trying to supply correct inputs.

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

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

States a specific verb ('synthesize') and resource ('composite multi-stage StrategyIR'), clearly distinguishing its role from siblings like propose_strategy by focusing on composing existing primitive strategies. Includes a concrete example (Graph Coloring + Topological Sort + Allocation) that makes its function 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?

Implies usage when multiple primitive strategies exist, as it says 'from primitive strategies', but provides no explicit when-to-use or when-not-to-use guidance. Does not contrast with alternatives like propose_strategy or identify_task, leaving the agent to infer the selection logic.

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 says 'compute' which implies a non-mutating pure calculation, but it does not explicitly state whether there are side effects, permissions required, or what happens to inputs. The behavioral profile is under-specified.

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 front-loads the action and resource. It lists the components efficiently without extra content or 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 has 6 parameters (1 required), nested objects, and an output schema, the description is insufficient. It fails to explain what each parameter means, how the inputs relate, or what behavioral expectations exist. The output schema helps with returns, but input semantics are almost entirely unaddressed.

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

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

Schema description coverage is 0% and the description does not explicitly map terms to parameters. Some hints exist (novelty/surprise to actual/predicted_state, empowerment to reachable_states, learning progress to skill_success), but these are vague and require inference. The description does not meaningfully compensate for the lack of schema documentation.

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

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

The description clearly states the tool computes intrinsic drives and lists specific components (novelty, prediction surprise curiosity, empowerment, learning progress). It uses a specific verb and resource, and the rich list distinguishes it from most sibling tools, though it doesn't explicitly name an alternative.

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

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

There is no guidance on when to use this tool versus alternatives, nor any conditions or exclusions. The description only states what it computes, leaving the agent to infer when it is appropriate. No sibling comparisons or usage context 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 of behavioral disclosure. It only says 'compute,' which hints at a pure function, but it does not mention side effects, state requirements, dependencies between parameters, or any performance or access considerations. This is insufficient for a tool with no annotation fallback.

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

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

The description is a single efficient sentence that front-loads the verb and resource. It avoids fluff, though it sacrifices useful detail for brevity. As conciseness, it is strong; as structure, it lacks any breakdown or headings, but that is acceptable for such a short text.

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

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

The tool has 6 parameters, nested objects, an output schema, and no annotations. A one-line description does not explain how inputs relate to outputs, what the output schema represents, or when to provide optional parameters like skill_name or reachable_states. The description is markedly incomplete for the complexity of 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 for parameter meaning. It mentions high-level concepts (novelty, empowerment, learning progress) but does not map them to actual_state, predicted_state, reachable_states, or other parameters. The agent cannot determine how to populate the arguments from this text alone.

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 ('Compute') and resource ('intrinsic drives'), then enumerates the exact components (novelty, prediction surprise, empowerment, learning progress). This is unambiguous and distinguishes the tool from generic compute tools, though it does not explicitly contrast with siblings.

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

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

No guidance is provided about when to use this tool versus alternatives such as compute_intrinsic_rewards or other cognitive compute functions. The description only states what it does, leaving the agent to infer applicability with no 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, the description must carry the full behavioral burden. 'Compute' implies a read-only operation, but the description does not disclose whether it mutates state, requires an existing lattice, handles a 'task' differently from a 'lattice', or what failure modes exist. No side effects, permissions, or return behavior are mentioned.

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 wasted words, which is structurally concise. However, it is terse to the point of being jargon-heavy and omits essential context, so brevity comes at the cost of clarity.

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

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

An output schema exists, so return-value documentation is not strictly required. But the tool is specialized, has no annotation safety profile, and has completely undocumented parameters; an agent still lacks the input semantics and selection criteria needed to call it correctly.

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

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

Schema description coverage is 0%, and both parameters (task_data, lattice_id) lack descriptions in the schema. The tool description mentions 'lattice or task' but never explains the roles of the two parameters, whether they are alternatives or complements, or how lattice_id relates to task_data. An agent cannot determine what to pass.

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 ('Compute') and resource ('lattice or task') and adds a distinctive qualifier ('coordinate-free topological invariant signature'). It is clearly a computation tool, but it does not explicitly distinguish itself from siblings like compile_invariant_lattice or verify_lattice_transition, so an agent must infer the boundary.

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

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

No guidance is given about when to use this tool versus its many siblings, particularly compile_invariant_lattice and verify_lattice_transition. There are no examples, prerequisites, or statements about which inputs are expected; the agent must guess from the name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states that the tool computes a signature. It does not disclose side effects, input requirements, error behavior, or what happens when both optional parameters are null. It is not misleading, but it is far too thin to be 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 a single front-loaded sentence with no filler or redundancy. It is concise and readable, though terseness comes at the cost of missing critical usage and parameter context.

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

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

Given the large sibling list, a nearly identical sibling tool name, and no annotations, the description is not complete enough for an agent to confidently select and invoke this tool. The output schema exists, but input semantics, selection criteria, and behavioral expectations are absent.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. 'Lattice or task' loosely maps to lattice_id and task_data, but it does not explain whether one is required, how they interact, or what constitutes valid data. The optional-by-default nature of both parameters is left unexplained.

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 action ('compute') and a specific resource ('coordinate-free topological invariant signature of a lattice or task'). The qualifier 'coordinate-free' hints at a distinction from the sibling compute_lattice_signature, but the description does not explicitly differentiate them.

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

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

No guidance is given about when to use this tool versus the closely named sibling cognitive.compute_lattice_signature or related lattice tools such as compile_invariant_lattice. There is no mention of required inputs, prerequisites, or alternative selection criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does indicate the set of mathematical operations the tool can perform, implying a pure computation, but it says nothing about how results are presented, what happens for invalid or missing parameters, how operations are selected, or whether there are side effects. The agent only learns a list of math topics, not the behavior of the 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 a single compact sentence that front-loads the domain ('Number theory') and then lists supported computations in a scannable comma-separated form. It wastes no words and is easy to parse quickly. The conciseness is commendable, though it comes at the cost of omitting the explanatory detail needed for parameter mapping.

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 9 parameters, no annotations, and 0% schema description coverage, this description is not complete enough for an agent to invoke correctly. The output schema covers return values, but the description still fails to document allowed operation values, required parameters per operation, or parameter constraints. It names the feature set without providing the per-operation contract needed to construct a valid call.

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 linking parameters to operations. It offers only weak hints: 'CRT' suggests moduli and remainders, 'extended GCD' suggests a and b, and 'modular inverse' suggests a and m. But it never explicitly maps each of the nine parameters to a specific operation, explains how they combine, or defines the valid operation string values. An agent must guess the invocation contract.

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 resource (number theory) and enumerates specific computations (primality, factoring, extended GCD, CRT, etc.), which distinguishes it from arithmetic, matrix algebra, or equation-system siblings. However, it lacks an explicit verb such as 'computes' or 'solves' — the action is only implied by the tool name and the domain label. It reads as a topic list rather than a statement of what the tool does.

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

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

No usage guidance is provided. The description never states when to prefer this tool over closely related siblings like cognitive.solve_arithmetic, cognitive.verify_arithmetic_claim, or cognitive.matrix_algebra, nor does it give conditions or exclusions. The only implicit signal is the topic list, which is insufficient for an agent deciding between competing 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 full burden of behavioral disclosure. It lists operation categories but does not mention return format, error behavior, side effects, or whether results are exact/deterministic. This is a significant gap for a compute 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 a single concise, front-loaded sentence with a comma-separated operation list; every word adds information. However, the list format lacks any structural guidance on parameters or usage, keeping it from a higher score.

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

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

Given the tool's complexity (9 parameters, 0% schema coverage, no annotations, and an unseen output schema), the description is woefully incomplete. An agent cannot determine valid operation strings, parameter roles, or invocation patterns from this text alone.

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

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

Schema description coverage is 0%, so the description must compensate for 9 cryptic parameters (a, b, c, k, m, n, moduli, remainders, operation). It names plausible operation values (primality, factoring, etc.) but does not map them to parameters or explain required inputs per operation, leaving most parameters unexplained.

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 performing number theory computations, listing specific operations like primality, factoring, extended GCD, and CRT. This distinguishes it from sibling math tools such as solve_arithmetic or matrix_algebra, though the verb 'compute' is only implied by the tool name.

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

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

There is no guidance on when to use this tool versus alternative cognitive math tools, nor any exclusions or prerequisites. The operation list implies usage for number theory problems, but the description does not state conditions or mention alternatives, leaving the agent to infer.

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 that it uses Pearl's abduction-intervention-prediction, which implies a three-step internal process (abduct, intervene, predict) and that it requires a causal model (via factual_trace), but it does not disclose potential limitations, such as the need for a fitted causal model, computational costs, or what happens if the intervention step is out of bounds. It adds some behavioral context beyond a simple 'computes counterfactuals' but leaves gaps.

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

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

The description is a single, concise sentence that front-loads the purpose ('Counterfactual engine') and the key evaluation question. It is efficient and avoids redundancy. It loses a point because it uses a colon and then the phrase 'using Pearl's...' which, while informative, could be seen as slightly technical and may be superfluous for some agents, but overall it is well-structured and to the point.

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 (requires a causal model, three-step procedure) and the absence of annotations, the description is adequate but not thorough. The presence of an output schema (not shown in detail but indicated by Has output schema: true) means the return value is documented elsewhere. However, it does not mention the need for a prior fitted causal model or the assumptions underlying Pearl's framework, which are critical for correct invocation. The description is complete enough for a high-level understanding but lacks operational details.

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

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

Schema description coverage is 0%, and the description does not mention any parameters by name. The description gives a high-level idea of inputs (factual_trace, intervention_step, counterfactual_action) but does not elaborate on their structure or semantics beyond what the schema provides. For instance, it doesn't explain that intervention_step must be a valid index within the factual_trace, or how counterfactual_action as a string is interpreted. The description fails to compensate for the lack of schema documentation.

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

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

The description clearly states it is a counterfactual engine for evaluating 'What if I had done X instead of Y at step t?' using Pearl's abduction-intervention-prediction. It names the specific verb 'evaluate' and the resource (counterfactual scenarios), and the method is specified. It distinguishes from siblings like cognitive.predict_world_state and cognitive.simulate_actions by focusing on counterfactual reasoning, though it does not explicitly name those alternatives.

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

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

The description implies when to use the tool: when you need to ask hypothetical counterfactual questions about past steps in a causal model. However, it does not explicitly state when not to use it or name sibling alternatives, such as cognitive.predict_world_state for forward simulation or cognitive.simulate_actions for exploring action outcomes without the causal framework. The context is clear but lacks explicit exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the method (abduction-intervention-prediction), which is a useful behavioral trait, but it does not disclose whether the tool is read-only, has side effects, or requires any specific permissions. The output schema covers return format but not operational behavior.

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

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

The description is a single sentence that is front-loaded with 'Counterfactual engine:' and then states the purpose. It is concise and wastes no words. While it is arguably too brief, it is structurally efficient and easy to scan.

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

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

This is a complex tool with 4 parameters, no parameter descriptions, and many sibling tools in the same domain. The description is too short to guide an agent on how to construct the factual trace, what intervention_step means, or how to format the counterfactual_action. Even with an output schema, the input semantics are missing, leaving the agent to infer too much.

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 0%, meaning the description must compensate by explaining parameter meanings, but it does not. The description only explains the tool's purpose and never mentions factual_trace, intervention_step, counterfactual_action, or dt. An agent would have no idea what each parameter expects beyond the schema's type definitions.

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 evaluates counterfactual 'what if' scenarios using Pearl's abduction-intervention-prediction framework. It names a specific verb (evaluate) and resource (counterfactual engine), making its purpose unambiguous. However, it does not explicitly contrast with sibling tools like simulate_actions or predict_world_state, so it lacks direct differentiation.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. The mention of Pearl's method hints at causal counterfactual reasoning, but there is no statement of when to prefer this over simulate_actions or predict_world_state, nor any exclusions. The 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 the full burden. 'Instantiate and initialize' indicates a creation action but does not disclose lifecycle behavior, idempotency, resource persistence, possible side effects, or what happens on repeated calls with the same env_id. It is not misleading, but it adds little beyond the tool's name.

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

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

A single, compact sentence with no filler. The verb and resource are front-loaded, and the parenthetical usefully enumerates the environment types. Every element earns its place.

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

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

For a creation tool with no annotationsable and an output schema exists, but the description still fails to explain how env_id should be used, what parameters contains, how env_type changes the environment, or any setup expectations. An agent cannot reliably call this tool correctly based on the current definition.

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 barely compensates. The parenthetical values (spatial_commons, multi_agent_arena, sequential_puzzle) hint at valid env_type options and match the schema default, but env_id and parameters are left entirely unexplained. The agent gains only partial meaning for one of 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 uses a specific verb ('Instantiate and initialize') and a clear resource ('simulated cognitive environment'), and lists plausible environment types. It vaguely distinguishes itself from siblings like step_simulated_environment by the act of creation, but it doesn't explicitly state how it differs from related simulation or experiment creation 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?

There is no guidance about when to use this tool versus alternatives such as cognitive.step_simulated_environment, cognitive.run_multi_agent_simulation, or cognitive.start_experience. The description implies creation precedes stepping but never states this or mentions any preconditions, sequencing, 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Instantiate and initialize' implies creation, but the description does not reveal whether this is destructive to existing environments, whether it requires special permissions, what lifecycle state the environment enters, or what the response contains. With zero annotation coverage, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no filler words. The core action and the key value set (environment types) come first. It earns high marks for efficiency, though it could have been slightly longer without harm to cover parameters and behavior.

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

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

Given zero annotations, 0% schema description coverage, and a non-trivial 3-parameter input, the description leaves too many gaps. The presence of an output schema mitigates return-value ambiguity, but an agent still lacks guidance on how to configure parameters, when to include env_id, and what side effects creation entails. The description is only marginally more useful than the tool name.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's silence. It does list the allowed env_type values (spatial_commons, multi_agent_arena, sequential_puzzle), which adds meaning to that parameter. However, it says nothing about env_id (e.g., uniqueness, reuse, override semantics) or parameters (e.g., what keys are accepted, whether it is optional). Two of the three parameters remain completely unexplained.

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

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

The description names a specific verb ('instantiate and initialize') on a specific resource ('simulated cognitive environment') and enumerates the concrete environment types (spatial_commons, multi_agent_arena, sequential_puzzle). This clearly distinguishes it from siblings like cognitive_step_simulated_environment and cognitive_run_multi_agent_simulation, leaving no ambiguity about what the tool 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 gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The purpose implies usage, but the description does not explicitly say 'use this when you need to create a new simulated environment' nor does it contrast with related tools such as the run_multi_agent_simulation or step_simulated_environment siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool performs adversarial perturbations and returns a Robustness Index plus hardened paths, which is useful. However, it does not mention side effects, mutability, input requirements, or failure modes. For a computation-oriented tool this is moderately transparent 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 a single, dense sentence with no wasted words. It front-loads the core action and outcome, making it easy to scan. Every term contributes meaning, and there is no redundant or filler 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 description lacks essential context for a 6-parameter tool with zero annotations and zero schema coverage. It introduces domain jargon (lattice, Robustness Index, hardened paths) without definitions, does not clarify parameter semantics, and provides no guidance on when or how to use the tool. An agent would struggle to call this tool correctly based solely on this description.

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

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

Schema description coverage is 0%, so the description must compensate. It hints at 'trajectories' and 'perturbations', which maps loosely to the trajectory and stress_amplitude/max_perturbations parameters, but it does not explain lattice_id, lattice_data, step_budget, or how the parameters interrelate. This is insufficient for correct invocation with 6 optional 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 states a specific action ('Subject candidate trajectories to adversarial algebraic perturbations') and a concrete outcome ('calculate Robustness Index (R) and project hardened paths'). It clearly identifies the tool's purpose and distinguishes it from generic compute tools, though it does not explicitly contrast with sibling tools such as cognitive.counterfactual_what_if or cognitive.project_to_manifold.

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, no mention of prerequisites, and no stated exclusions. The description only says what the tool does, not when an agent should choose it. With many cognitively-themed siblings, this 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?

With no annotations, the description carries the full burden of behavioral disclosure. It implies a computation (calculate Robustness Index, project paths) but does not state whether it mutates inputs, requires specific data formats, or has side effects. No safety or reversibility information is provided, which is a significant gap for a tool with no annotation safety hints.

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 that is concise and front-loaded with the core action. It contains no filler or redundant information, making it easy to parse quickly.

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 6 parameters, all optional with defaults, and no schema descriptions, the description is insufficient. It does not explain how parameters influence the stress test, what 'hardened paths' means operationally, or what prerequisites exist (e.g., need for lattice_data). The output schema exists, so return format is covered, but input usage is unclear.

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 by explaining parameter meanings. It vaguely references 'trajectories' and 'perturbations' but does not explicitly map to any of the six parameters (lattice_id, trajectory, step_budget, lattice_data, stress_amplitude, max_perturbations). No parameter-specific meaning is added beyond the schema's type and name.

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 action ('Subject candidate trajectories to adversarial algebraic perturbations'), the metric computed ('Robustness Index (R)'), and the output ('project hardened paths'). This clearly distinguishes it from the sibling 'cognitive.crucible_stress_test' by specifying the adversarial algebraic nature and the robustness 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. There is no mention of conditions, prerequisites, or when to prefer a different stress-test or lattice tool. The description only states the action, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions evaluating support status and confidence but does not state whether the operation is read-only, whether it requires prior evidence graph construction, what confidence scales are used, or any side effects or prerequisites.

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

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

The description is a single efficient sentence with no filler, and the primary action is front-loaded. It loses a point because it is so brief that it omits any supporting context for a complex 9-parameter tool, but as a concise statement it is well-formed.

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 9 parameters, 0% schema description coverage, no annotations, and a large sibling family, the description is not complete enough. It only covers the core purpose and fails to provide usage context, parameter semantics, or behavioral boundaries. The presence of an output schema helps but does not resolve these gaps.

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

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

Schema description coverage is 0%, and there are 9 parameters, so the description must compensate. It only vaguely references 'claim' and 'evidence', while optional fields like object, subject, relation, assumptions, dependencies, and invalidation_conditions are entirely unexplained. The phrase 'with evidence' could even mislead, since evidence is optional per the schema.

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

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

The description states a specific verb ('Evaluate') and resource ('support status and confidence for an individual claim'), which is clear and distinguishes it from graph-level tools like cognitive.build_evidence_graph or cognitive.audit_evidence_graph. It does not explicitly name a sibling, but the 'individual claim' scope is sufficient for basic differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like cognitive.evaluate_cooperation, cognitive.verify_arithmetic_claim, and cognitive.get_final_evidence_result, an agent receives no explicit condition for choosing this tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'evaluate support status and confidence.' It does not state whether the tool modifies the evidence graph, whether it is read-only, how it handles incomplete evidence, or what side effects might occur.

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 11-word sentence with no filler and a clear front-loaded verb. It is appropriately concise for the core purpose, though the brevity leaves deeper context to be covered in other dimensions.

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 9 parameters, no annotations, and 0% schema description coverage, the description is too sparse. Even though an output schema exists, an agent still lacks guidance on how to provide evidence, what role relation/invalidation_conditions play, and when this evaluation is the right choice among many cognitive siblings.

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

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

Schema description coverage is 0%, and the description compensates almost not at all: it mentions 'evidence' but says nothing about the required 'claim' parameter or the meaning of object, subject, relation, assumptions, dependencies, task_structure_id, or invalidation_conditions. The parameter names are suggestive but the description adds no real semantic value.

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

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

The description states a specific verb ('Evaluate') and resource ('support status and confidence for an individual claim with evidence'), so an agent can grasp the core function. However, it does not differentiate itself from near-identical siblings such as cognitive.evaluate_claim_evidence or from cognitive.verify_* 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?

There is no guidance on when to use this tool versus alternatives like build_evidence_graph, audit_evidence_graph, verify_arithmetic_claim, or evaluate_claim_evidence. The description gives no selection criteria, exclusions, or context around prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It states the core operations (analyze payoff matrices, compute equilibria, execute policies) but does not disclose important behaviors such as whether the tool mutates any state, requires authentication, or what happens with missing optional parameters. A tool that executes policies likely has side effects, but this is not clarified, which is a gap 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 a single concise sentence that front-loads the main purpose and lists three concrete operations. It is efficient with no fluff, though it could benefit from a brief parameter note. The structure is appropriately succinct.

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 complexity (7 parameters, 0% schema coverage, no annotations, no enums) and an output schema present, the description is insufficient. It does not explain the input parameters, the expected output, or provide guidance on how to use the tool correctly. Agents would likely need to inspect the schema and guess semantics, which is risky for a tool that executes policies. More details on parameter usage and prerequisites are needed.

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, but it does not explain any of the 7 parameters. The description mentions 'game payoff matrices' but does not clarify how parameters like 'endowments' or 'multiplier' feed into that. Agents are left to infer parameter meaning from names alone, which is insufficient for subtle fields like 'my_history' and 'partner_history'.

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's purpose: analyzing game payoff matrices, computing Nash/Pareto equilibria, and executing reciprocity policies. This is specific and distinguishes it from siblings like cognitive.compose_strategies and cognitive.propose_strategy, which focus on strategy creation rather than analysis. However, it does not name these siblings explicitly, so a 5 is not warranted.

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 analyzing cooperation in multi-agent settings), but it does not explicitly state when not to use it or mention alternatives. For instance, it could note that strategy creation should use cognitive.propose_strategy. This lack of explicit routing keeps it at a 3.

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 does reveal core behaviors—analyzing payoff matrices, computing Nash/Pareto equilibria, executing reciprocity policies—but it is silent on side effects, required permissions, or whether 'execute' mutates state. This is partial disclosure rather than full transparency.

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

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

The description is a single compact sentence, front-loaded with the domain label and a readable action list, with no filler. It earns a 4 because the brevity is efficient, though it contributes to the parameter and usage gaps.

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

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

For a tool with seven parameters, no annotations, and no schema-level descriptions, this is incomplete: an agent cannot know valid game_type formats, how histories and contributions are encoded, or what side effects 'execute reciprocity policies' implies. The existence of an output schema reduces the return-value burden, but the input side remains under-specified.

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 names none of the seven parameters (game_type, strategy, endowments, multiplier, my_history, contributions, partner_history). It adds no semantic meaning beyond the schema's bare type/default information and fails to compensate for the low 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 names a specific domain ('multi-agent cooperation'), a resource ('game payoff matrices'), and concrete actions ('analyze', 'compute Nash/Pareto equilibria', 'execute reciprocity policies'). It is clear and not a tautology, but it does not distinguish itself from closely related siblings such as compose_strategies or theory_of_mind.

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 sentence states when to choose this tool over alternatives; there are no exclusions, prerequisites, or 'use X instead' pointers. The only implied trigger is the domain label 'multi-agent cooperation', which is too weak to route an agent reliably among the many cognitive siblings.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It indicates a read/evaluate action, but does not state whether the operation is read-only, requires existing plans or task structures, performs any state changes, or has side effects. The behavior is only minimally implied by the word 'Evaluate'.

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 inline examples, which is compact and front-loads the core purpose. It earns its place, though it sacrifices meaningful detail 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?

Given 0% schema description coverageže, 4 parameters, and no annotations, the description is not complete enough for reliable invocation. It leaves unclear the relationship between `plan_id` and `task_structure_id`, the expected shape of `parameters`, and the range of acceptable `query_type` values. The output schema exists, which helps, but does not compensate for the missing input semantics.

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

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

Schema description coverage is 0%, and the description does not explain the parameters beyond referencing a 'plan' and giving examples of query types. It does not clarify what `task_structure_id` is for, what `parameters` should contain, or how `query_type` values are formatted. With four parameters and zero schema descriptions, this 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 states a clear verb ('Evaluate') and resource ('a counterfactual query on a plan'), with concrete examples ('What if capacity drops?', 'What if a route fails?'). It is specific enough to be understood, but it does not distinguish itself from closely named siblings like cognitive.counterfactual_what_if or cognitive.plan_with_counterfactuals.

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 examples imply that this tool is for hypothetical 'what if' scenarios on plans, but there is no explicit guidance on when to use this tool versus sibling tools such as cognitive.counterfactual_what_if or cognitive.plan_with_counterfactuals. No exclusions or alternative conditions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Evaluate a query' weakly implies a read-only analysis, but the description does not state whether the plan is mutated, whether results are returned, or what side effects occur. This is a meaningful transparency gap for a tool with no annotation safety profile.

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

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

The description is a single, front-loaded sentence with no filler. Every part earns its place: the verb, the target resource, and two clarifying examples that make the purpose concrete.

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 an output schema exists, this is a 4-parameter tool with no annotations, no enum values, and 0% schema description coverage. The description explains the high-level intent but omits parameter semantics, usage boundaries, and distinctions from closely related cognitive tools, so an agent is not fully equipped 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%, so the description must compensate for the four otherwise unexplained parameters. The 'What if capacity drops?' examples hint at how query_type and parameters might be used, but the description never explains required fields like task_structure_id, optional plan_id, or the expected shape of parameters. It adds conceptual value but not enough parametric guidance.

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 begins with a specific verb and resource: 'Evaluate a counterfactual query on a plan', and gives concrete examples ('What if capacity drops?', 'What if a route fails?') that make the operation identifiable. It does not, however, distinguish itself from sibling tools like cognitive.counterfactual_what_if or cognitive.plan_with_counterfactuals, so it stops short of strong differentiation.

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

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

The phrase 'on a plan' and the example counterfactual questions imply when the tool is appropriate, but there is no explicit when-to-use, when-not-to-use, or mention of alternative sibling tools. An agent must infer usage from the examples rather than being directed to the right tool.

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

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

No annotations are present, so the description must carry the full burden. It states only 'Evaluate', which implies a non-mutating analysis, but does not disclose any side effects, permissions, or operational constraints. The description adds no information beyond the action itself.

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

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

The description is a single concise sentence with no filler. It front-loads the verb and resource, making the tool's purpose immediately clear.

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

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

Given that the output schema exists, return values are covered elsewhere, but the description does not explain the parameter, any usage constraints, or any behavioral traits. For an otherwise simple tool, the description is thin and leaves an agent guessing about the benchmark_filter values and the intended 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?

The sole parameter 'benchmark_filter' is not described anywhere in the description, and the schema provides no description (0% coverage). The name suggests a filter, but the accepted values, default behavior, and format are left entirely unexplained. The description does not compensate for this missing schema context.

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

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

The description names a specific verb ('Evaluate') and a specific resource ('broad generalization across spatial commons, multi-agent arenas, and sequential causal puzzles'). It delineates the scope of the tool clearly, though it does not explicitly contrast it with sibling tools such as evaluate_cooperation.

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. The description simply states what it does, leaving the agent to infer context. No prerequisites or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only says 'Evaluate' without stating whether it is read-only, what side effects exist, what the output format is, or any prerequisites. It does not contradict annotations (there are none), but it adds little beyond the name.

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

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

The description is a single, front-loaded sentence with no filler. It states the action and the scope immediately. While it could be more informative, it is efficiently structured and avoids 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 tool with one parameter and no annotations, the description is too sparse. It does not clarify what 'broad generalization' means, what the benchmark domains entail, how the filter works, or what output to expect. Even with an output schema (not shown), the description leaves significant ambiguity about how to 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 description coverage is 0% and the description does not mention the benchmark_filter parameter at all. The parameter has a default of null and is optional, but its meaning and acceptable values are entirely unexplained. The description fails to compensate 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 states a specific verb ('Evaluate') and a clear resource: broad generalization across three named domains (spatial commons, multi-agent arenas, sequential causal puzzles). This is not a tautology and distinguishes the tool from many siblings, though it does not explicitly reference alternatives.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context about scenarios where this is appropriate, nor does it mention any exclusions or sibling tools for comparison. An agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full behavioral burden and does disclose a conditional path (missing raw → guidance_only), a response envelope, and the complete set of possible statuses including blocked_until_clarified and refused_infeasible. It does not cover side effects or prerequisites, but the status and conditional behavior detail is 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?

The one-line pipeline summary front-loads the core purpose, and the Parameters/Returns sections are clearly organized. The description is long due to example payloads, but those examples earn their place by disambiguating accepted raw formats.

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 complexity of the tool and the generic input schema, the raw-format examples and status list are valuable, and the output schema covers return fields. Still, the description does not explain how goal, environment, or model_family affect the orchestration, nor what triggers statuses like blocked_until_clarified vs. refused_infeasible.

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 adds significant meaning to the 'task' parameter, including nested structure and eight concrete raw payload examples, which is essential given the 0% schema coverage. However, 'goal', 'environment', and 'model_family' are left completely unexplained despite being free-form schema properties, so the coverage is uneven.

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 identifies a concrete behavior: 'One-call orchestration' with a staged pipeline (identify → gate → guide → solve → verify → report). This goes beyond a tautology and implies that this tool consolidates several cognitive steps, though it does not explicitly name or differentiate 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?

It provides practical invocation guidance by listing supported problem types and clarifying that omitting task.raw yields a guidance_only response with expected_raw_formats. However, it never says when to prefer this orchestrator over individual siblings like cognitive.identify_task or cognitive.solve_arithmetic, and it offers no 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?

With no annotations, the description carries the behavioral burden and does a good job: it discloses the orchestration flow, the guidance-only fallback, the possible status values, and the return envelope. It does not discuss side effects, permissions, or resource consumption, but this appears to be a read-only/stateless orchestrator, so the disclosure is reasonably complete.

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 front-loaded with the orchestration pipeline and uses clear bulleted sections. The raw-format examples are verbose yet practically valuable for invoking the tool correctly; minor trimming of redundant phrasing would improve 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?

For a complex tool with an output schema, the description covers statuses, raw formats, and response envelope well. Still, it leaves the semantics of goal, environment, and model_family unexplained, and it treats task as central while the schema marks it optional, creating ambiguity about what a minimal valid invocation looks like.

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

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

The description thoroughly documents the task parameter and provides detailed examples for eight raw problem types. However, goal, environment, and model_family receive no explanation beyond their names in the JSON schema, and with 0% schema coverage, the description fails to compensate for most 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 identifies the tool as a one-call orchestrator that handles an end-to-end pipeline (identify → gate → guide → solve → verify → report). It is distinct from narrower sibling tools like cognitive_identify_task or cognitive_get_guidance, though it does not explicitly name those alternatives.

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

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

The description implies usage: supply task_structure and raw to execute, or omit raw to receive guidance_only with expected_raw_formats. It gives supported problem types but never explicitly says when not to use this tool or when to choose a sibling, which matters given the large sibling list.

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

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

No annotations are provided, so the description carries the full burden. It does disclose important behavior: it extracts structural invariants and registers an initial candidate strategy immediately. Still, it does not explain what 'registers' entails (persistence, overwrites, reversibility) or potential failure modes.

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

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

The description is concise and front-loaded with the core purpose, followed by a single sentence of useful elaboration. It avoids filler and does not repeat schema fields, though the phrase 'few-shot learning' is somewhat redundant with the tool name.

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 0% schema coverage, no annotations, nested objects, and 4 parameters including 2 required ones, an agent would need more detail to invoke the tool correctly. The output schema helps with return semantics, but the description does not specify what solution_trace must contain, what task_structure_id refers to, or the role of strategy_name.

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, but it never names task_structure_id, solution_trace, source_model, or strategy_name. The phrase '1-3 problem traces' hints at solution_trace but does not clarify its structure or how multiple traces are represented within that single object.

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 ('induce') and resource ('generalized procedural StrategyIR') with a clear source scope ('from 1-3 problem traces'). It also names the extracted artifacts, which distinguishes this few-shot learning tool from sibling strategy tools like propose_strategy and compose_strategies.

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: few-shot learning with 1-3 traces and no large training sets. However, it does not explicitly say when to prefer this over sibling tools such as cognitive.propose_strategy, cognitive.learn_from_mistake, or cognitive.compose_strategies, nor does it provide exclusion criteria.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose concrete behaviors: extracting structural invariants and registering an initial candidate strategy immediately. Still, it does not explain side effects of 'registers' — whether existing strategies are overwritten, whether this is reversible, or whether any verification happens.

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 every clause contributes either scope, behavioral detail, or rationale. There is no filler or repetition of the tool name.

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?

While an output schema exists, the description is incomplete for an invocation: task_structure_id is required but unexplained, the expected shape of solution_trace for '1-3 problem traces' is ambiguous, and the consequences of registering a candidate strategy are not stated. This leaves real gaps for correct 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 indirectly clarifies that solution_trace contains problem traces, but it never addresses the required task_structure_id, nor the optional strategy_name and source_model. An agent would not understand how to fill the required parameters correctly from this text alone.

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 ('induce') and resource ('generalized procedural StrategyIR'), and scopes the operation by 'from 1-3 problem traces'. It is distinguishable from sibling tools like compose_strategies or propose_strategy, though the domain jargon 'StrategyIR' is not unpacked.

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 'Few-shot learning' and 'from 1-3 problem traces' implies the appropriate context: use when only a few traces are available. However, there is no explicit guidance about when not to use it or how it compares to alternatives like learn_from_mistake, propose_strategy, or verify_strategy.

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 states the tool is 'autonomous' and performs 'multi-criteria prioritization,' but does not disclose whether it mutates goal state, replaces existing goals, requires prior conditions, or has side effects—critical gaps for an agent deciding to invoke it.

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

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

A single dense sentence with no filler, front-loading the core action before elaborating input sources. However, the heavy jargon reduces readability, and splitting the description into purpose versus behavior would make it clearer.

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

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

Given five optional parameters, no annotations, and an output schema, the description is too thin. It fails to explain the meaning of max_active or goal_status_update, what 'multi-criteria prioritization' entails, and in what situations an agent should call this rather than a sibling 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 maps three parameters conceptually ('world deficits' to world_state, 'depleted reserves' to depleted_reserves, 'exploration frontiers' to unexplored_frontiers), but leaves max_active and goal_status_update unexplained, and offers no details on expected formats or semantics for the mapped 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 identifies a specific verb+resource ('goal synthesis') and names the input sources (world deficits, depleted reserves, exploration frontiers) and prioritization behavior. This distinguishes it from sibling tools like compose_strategies or propose_strategy, though the jargon ('autonomous', 'deficits', 'frontiers') makes it less crisp than ideal.

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

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

There is no guidance on when to use this tool versus alternatives such as cognitive.propose_strategy, cognitive.compose_strategies, or cognitive.identify_task. No exclusions, preconditions, or contextual triggers are provided, leaving the agent to infer usage solely from the name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does convey that the tool autonomously synthesizes goals and applies multi-criteria prioritization, which is meaningful. However, it does not disclose side effects, persistence, whether existing goals are replaced, or any safety-relevant behavior.

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

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

The description is a single efficient sentence with the core action front-loaded. It earns its place but is dense with jargon ('world deficits', 'depleted reserves', 'exploration frontiers') that could reduce clarity for an agent.

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 five optional parameters, no annotations, and 0% schema coverage, yet the description provides no usage context, no sibling differentiation, and no explanation of two parameters. The presence of an output schema helps, but the description alone is not sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It loosely maps three parameters: 'world deficits' to world_state, 'depleted reserves' to depleted_reserves, and 'exploration frontiers' to unexplored_frontiers. It entirely omits max_active and goal_status_update, leaving two of five parameters semantically unexplained.

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 action ('goal synthesis') and a resource ('goals'), and adds meaningful scope by naming input sources: world deficits, depleted reserves, and exploration frontiers. It is clear, but it does not explicitly distinguish this tool from close siblings like cognitive.compose_strategies or cognitive.arbitrate_temporal_objectives.

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 invoke this tool versus alternatives such as cognitive.generate_and_prioritize_goals (dot-form), cognitive.compose_strategies, or cognitive.hierarchical_plan. The phrase 'Autonomous goal synthesis' implies a use case, but no conditions, prerequisites, or exclusions are stated.

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

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

With no annotations, the description itself must indicate behavioral traits. 'Retrieve' correctly implies a read-only operation, and mentioning benchmark results adds useful context. But it does not disclose behavior on missing IDs, access constraints, or notable limitations.

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 compact, front-loaded sentence with no filler. Every word contributes to understanding the tool's core purpose, though the section references are cryptic without added explanation.

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

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

This is a simple one-parameter retrieval tool, and the output schema exists, so the description does not need to explain return values. The main gap is the absence of any usage guidance or parameter detail, but overall the definition is sufficient for correct invocation.

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

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

Schema description coverage is 0% for the single parameter, and the description adds almost nothing beyond the schema's own 'Experiment Id' title. It does not explain what format the ID takes, where to find it, or any 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 uses a specific verb ('Retrieve') and a clear resource ('experiment'), and even enumerates the returned content ('details and benchmark results'). This distinguishes it from sibling tools about guidance, strategy, or experience tracking.

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

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

Usage is implied: an agent would call this when experiment details or benchmark results are needed. However, there is no explicit statement of when to use it versus alternatives, nor any exclusion or prerequisite information.

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. 'Retrieve' signals a read-only operation, but the description discloses no additional behavioral context such as auth requirements, side-effect guarantees, or error/rate-limit behavior. The section references are opaque.

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

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

The description is a single front-loaded sentence with no redundant wording. It loses a point for the cryptic '(§24, §69)' suffix, which is likely noise for an AI agent, and for lacking any structuring of usage context.

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

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

For a simple one-parameter read tool with an output schema, the description is nearly sufficient: an agent can infer it needs an experiment_id and will receive details/results. However, the absence of usage guidance, parameter provenance, and differentiation from the dot-form sibling leaves selection and invocation partly to inference.

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

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

The schema provides only a `string` experiment_id with 0% description coverage, and the description never mentions the parameter or how to obtain/format it. The word 'experiment' maps loosely to experiment_id, but no semantic value is added beyond the property name.

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 ('an experiment') and specifies the content ('details and benchmark results'). It is not a tautology, but it does not differentiate from the near-identical sibling `cognitive.get_experiment`, and the § references add no clarifying value.

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

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

There is no explicit guidance on when to choose this tool over the many get_* siblings, nor any exclusions or prerequisites. The only usage signal is the implied 'when you need experiment details', which is not enough to distinguish it from the duplicate dot-form 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?

No annotations are provided, so the description must carry the transparency burden. It does disclose meaningful behavioral scope by listing what the result includes: supporting evidence, assumptions, missing evidence, contradictions, unchecked dependencies, confidence, and invalidation conditions. However, it does not disclose side effects, read-only guarantees, or any dependencies on prior evidence-gathering steps.

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

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

The description is a single, efficient sentence that fronts the action ('Compile a final evidence result') and then details the result's contents. It is dense but not bloated; the enumeration is long but each item contributes meaning.

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

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

The output composition is reasonably described, and an output schema exists, but the tool has no annotations, two undocumented parameters, and no usage guidance. An agent cannot confidently know what to pass or when to prefer this tool over closely related evidence tools, making the definition incomplete for correct invocation.

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

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

Schema description coverage is 0%, and the description does not explain the meaning or relationship of task_structure_id or target_id. The agent is left to infer that task_structure_id identifies some task structure, while target_id's purpose is completely unexplained. The description does not compensate for the schema's lack of parameter documentation.

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

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

The description uses a specific verb, 'Compile', and identifies a clear resource, 'a final evidence result', while enumerating the exact content categories. It is clearly differentiated from siblings like audit_evidence_graph by focusing on producing a final consolidated result, though it does not explicitly name an alternative.

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

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

There is no guidance about when to use this tool versus alternatives such as build_evidence_graph, audit_evidence_graph, or evaluate_claim_evidence. No exclusions, prerequisites, or contextual signals are given, leaving the agent to infer usage solely from the tool name and description.

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

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

With no annotations supplied, the description carries full responsibility for disclosing side effects and behavior, but it only lists output content. It does not indicate whether the operation is read-only, whether it requires prior evidence compilation, or what happens if evidence is incomplete. This leaves important behavioral traits unstated.

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 that efficiently packs the core action and output categories without extraneous words. It is front-loaded with the main verb and object. The dense list is acceptable, though it could benefit from breaking the output items into structured form.

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 an output schema exists and reduces the need to explain return values, the tool still lacks guidance on parameter meaning, usage context, and prerequisites. With no annotations and no alternative routing, an agent cannot fully determine when and how to invoke this tool. The description covers only the content of the result, not the surrounding operational context.

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

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

Schema description coverage is 0%, so the description is the only place to explain target_id and task_structure_id. It never mentions either parameter or how they influence the compiled result. The agent is left without any guidance on what values to supply or why task_structure_id is required.

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

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

The description states a specific action, 'Compile a final evidence result,' and enumerates the exact content categories it includes, making the tool's purpose clear. This resource is distinct from siblings like build_evidence_graph or audit_evidence_graph, though the description does not explicitly contrast them. The verb 'compile' vs the tool name 'get' introduces minor ambiguity about whether it retrieves or constructs the result.

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 information about when to use this tool instead of related evidence tools, such as cognitive_audit_evidence_graph or cognitive_build_evidence_graph. There are no stated prerequisites, use cases, or exclusions. An agent must rely on the tool name and implicit context to decide when this tool is appropriate.

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

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

With no annotations to carry safety or side-effect information, the description takes on the full burden and does so well. It discloses a key filtering behavior (unverified/suspended strategies are not returned as trusted guidance), what the response includes (calibrated uncertainty, applicability conditions, negative transfer warnings), and the failure contract (structured error object, never a bare exception). This is strong behavioral disclosure 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 tightly structured: a one-line summary, a clarifying negative guarantee, a sentence on output characteristics, and a compact Args/Returns breakdown. Every sentence contributes information, and the most important scoping statement is front-loaded before parameter 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?

For a tool with five parameters, no annotations, and an output schema, the description covers everything an agent needs to call it correctly: what it does, what it filters out, what each parameter means, what the return looks like, and what failure looks like. Nothing essential appears to be missing.

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

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

Schema description coverage is 0%, so the description must compensate for all five parameters. The Args section defines each one meaningfully: task_structure_id is a UUID, goal includes metric targets, available_capabilities means capabilities supported by the caller, and model_family gives examples. This adds real semantic value beyond the bare schema property names and types.

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

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

The description states a specific verb and resource: "Retrieve applicable validated strategies for a task." It further distinguishes itself from siblings like get_strategy by emphasizing 'applicable validated strategies' and explicitly excluding unverified or suspended ones. This is unambiguous and lets an agent differentiate it immediately.

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 use when an agent needs validated strategies for a given task, and the parameters hint at personalization via capabilities, environment, and model family. However, it never explicitly says when to prefer this over sibling tools such as get_strategy or propose_strategy, nor does it provide exclusion conditions. Usage context is clear but alternatives are not addressed.

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