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

With no annotations, the description carries the full burden. It discloses key behaviors: hash-locking for role='baseline' (write-once, tamper-proof), disabling sourcePath, and using measurement for tool-measured artifacts. However, it does not cover idempotency, error handling, or other 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 (two sentences) and front-loaded with the core action. Each sentence provides essential information without redundancy: first states the primary function, then adds critical constraints on role and measurement.

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 (10 parameters, no output schema, no annotations), the description covers the main purpose and key constraints but lacks details on return values, error cases, and usage of other parameters like loop, phase, and rationale.

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 low (20%), but the description adds meaning to parameters like role (hash-lock behavior), measurement (tool-measured), and sourcePath (disabled). It does not address other parameters (loop, name, phase, content, etc.), leaving some gaps.

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

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

The description clearly states the tool's purpose: 'Persist a raw artifact (run log, baseline copy) with a sha256 hash.' It specifies the resource (artifact) and action (persist), and distinguishes from siblings by mentioning hash-locking for baselines and measurement capabilities.

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 (e.g., for persisting artifacts with integrity, especially baselines) but does not explicitly state when not to use it or compare with alternatives. Sibling tools like observation_record or run_campaign are not mentioned, leaving the agent to infer context.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool freezes a benchmark, defaults benchPartition to gate, and makes worker benchmark_propose a no-op. However, it does not elaborate on side effects, permissions, or error conditions, but the disclosed behavior is sufficient for core understanding.

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 at two sentences, with no wasted words. It front-loads key information (purpose and usage context). While it could benefit from clearer structure, it is efficient and direct.

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 (5 parameters, nested objects, no output schema), the description leaves gaps. It does not explain what 'freeze' means in terms of lifecycle, return value, or error handling. It covers the main intent but lacks completeness for full contextual understanding.

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

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

Schema description coverage is low (40%). The description adds meaning only for benchPartition (defaults to gate). It provides no additional information for parameters like runId, newEpoch, benchmark, or rationale, which are left to the schema descriptions 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 clearly states the tool's purpose: 'freeze a benchmark directly (benchSource:maker) without worker benchmark_propose'. It specifies the resource (benchmark) and action (freeze), and differentiates from sibling tool benchmark_propose by indicating it is for maker-only direct freezing.

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

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

The description explicitly indicates when to use this tool ('Bench-maker only' and 'without worker benchmark_propose') and what happens when it is used ('Worker benchmark_propose becomes a no-op'). It also specifies the default behavior for benchPartition, providing clear context for usage vs alternatives.

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

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

No annotations are provided, so the description carries full burden. It only mentions the core action and rejection condition, but lacks details on side effects, error handling, permissions, or state changes. For a creation tool, more behavioral context is needed.

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

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

Two sentences, front-loaded with the main action, and a second sentence adding essential constraints. No wasted words.

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

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

Given the tool's complexity (nested object with 7 subfields) and no output schema, the description only covers the high-level requirement. It omits explanations of subfields (oracle, qualityScale, comparisonRule) and what constitutes a 'concrete case', making it incomplete for an agent to correctly formulate inputs.

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

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

Schema description coverage is 0%. The description adds some meaning by implying the 'benchmarks' array must contain subfields (task-value dimensions, resource dimensions, cases), but it does not explain individual properties like 'name', 'oracle', 'qualityScale', etc. Many parameters remain unclear to an agent.

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

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

The description clearly states the verb ('Propose') and the resource ('benchmark scorecards built from real prior uses/failures'). It includes specific constraints (≥1 task-value dimension, ≥1 resource/cost dimension, ≥1 concrete case) that help differentiate it from sibling tools like benchmark_select or benchmark_run.

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 strong context for when to use (proposing benchmarks with real prior uses/failures) and includes rejection criteria (hand-waved benchmarks). However, it does not explicitly state when not to use it or mention alternatives like benchmark_select.

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

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

Without annotations, the description carries the full burden. It discloses that measurementRef must be from a raw artifact and that model self-report never sets the bar, but does not describe other behavioral traits like whether it is destructive, permissions needed, or what the outcome of recording a run entails.

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

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

Two efficient sentences with no wasted words. The first sentence states the purpose, the second adds a critical constraint. Front-loaded 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 no output schema and no annotations, the description is adequate for the basic purpose and a key constraint, but lacks details on return values, side effects, or integration with sibling tools. It is minimally complete for an agent.

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

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

The schema has low coverage (33%), but the description adds meaning for 'measurementRef' (recorded raw artifact) and 'arm' (baseline sets bar). This compensates for the missing schema descriptions, though 'runId' remains 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 the specific action 'Record a tool-measured run of an arm through the frozen benchmark' and distinguishes the arm 'baseline' as a special case that sets the bar. This is a specific verb+resource and differentiates from siblings like 'reverify_run' or 'initialize_loop_run'.

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

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

It provides clear context: requires a measurementRef from a recorded raw artifact, not model self-report. While it doesn't explicitly exclude alternatives, it gives enough guidance on prerequisites and the special role of 'baseline'.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the operation freezes the benchmark immutably and requires a precondition, but does not detail side effects, permissions, error conditions, or return values. The description adds value but lacks comprehensive behavioral context.

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

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

The description consists of two sentences that efficiently convey purpose, precondition, and change guidance. No unnecessary words; information is front-loaded.

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

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

Given four parameters, no output schema, and no annotations, the description lacks completeness. It does not explain how to use the parameters (especially newEpoch and rationale beyond the change scenario), nor does it describe the return value or error conditions. More detail is needed for full self-containment.

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 the roles of 'newEpoch' and 'rationale' (for changing a frozen benchmark), but does not explain the other parameters (runId, benchmarkId) or provide explicit mapping. This is insufficient for four parameters.

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

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

The description clearly states the verb 'freeze' and the resource 'proposed benchmark as the immutable scorecard for this cycle,' which distinguishes it from sibling tools like benchmark_propose and benchmark_run.

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 specifies a precondition: 'Requires the baseline to be hash-locked first.' It also notes that changing a frozen benchmark requires a new epoch and rationale, providing clear usage context. However, it does not explicitly mention alternative tools or when not to use this tool.

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

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

Declares 'Read-only' (non-destructive) and notes that pending review does not block the campaign, adding useful behavioral context. However, with no annotations, it lacks details on authentication, error handling, or side effects like rate limits.

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

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

One sentence packed with specifics, front-loaded with 'Read-only supervisor status'. Efficient but slightly dense; could be broken into bullets or shorter clauses for readability.

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

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

Adequate for a simple read-only tool with one parameter: enumerates key data points. However, lacks explanation of output format or how the status items relate, and does not reference capabilities like pagination or limits.

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

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

The single parameter `runId` has 0% schema description coverage and the tool description does not mention it at all. The agent receives no guidance on its format, purpose, or how to obtain it, leaving the parameter semantically opaque.

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

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

The description clearly states it provides 'Read-only supervisor status' and lists specific resources (lane/target queue, auto-transitions, branch-retirement accounting, risk advisory band, pending review items). It distinguishes from sibling tools like loop_next or reverify_run which are action-oriented, but does not explicitly name alternatives.

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

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

No guidance on when to use this tool vs. any of the 23 siblings. It does not specify prerequisites (e.g., runId must be valid) or contexts where this status check is appropriate before actions.

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

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

With no annotations, the description carries the full burden. It discloses that the tool never asks the user, never marks the campaign complete, and does not clear the continuation obligation by itself. This provides key behavioral traits for safe invocation. It does not mention any destructive actions, which is appropriate given it is a recording tool.

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

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

The description is two sentences, efficiently conveying purpose and key behavioral constraints without extraneous words. The first sentence front-loads the primary action, and the second sentence clarifies limitations. Every sentence adds value.

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

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

Given 4 parameters, 50% schema coverage, no output schema, and no annotations, the description adequately covers usage context and behavioral traits. It explains when to use and what the tool does not do, which is sufficient for a recording tool. It could optionally mention the return value, but that is not critical.

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 50%, with 'lane' and 'firstAction' having descriptions. The description adds context by explaining 'next runnable improvement lane' and 'first concrete action,' aligning with parameter meaning. However, 'runId' (required) and 'rationale' (optional) are not elaborated in the description, leaving a gap for those parameters.

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

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

The description clearly states the tool records the next runnable improvement lane and first concrete action after specific events. It uses a specific verb ('record') and resource ('run', 'lane', 'action'), and distinguishes from sibling tools by noting it never asks the user or marks the campaign complete, which is unique among the listed siblings.

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

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

The description explicitly lists when to use the tool (after reports, dashboards, saturation findings, etc.) and states it does not mark the campaign complete nor clear the continuation obligation, implying it is an intermediate step. It advises that a 'real progress tool must run next,' providing clear guidance on context, though it does not explicitly name alternatives.

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

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

The description explains that the tool is a decision hook where only supervisor-accepted transitions count as progress, and that completion/stop intents are refused. While this gives some behavioral insight, it omits details on success/failure responses, side effects, or state changes.

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

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

The description is concise with two sentences that front-load the core purpose and constraints. However, it could be better structured by grouping related information (e.g., listing parameters with brief explanations).

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 (6 parameters, no output schema, no annotations, and 0% schema coverage), the description is incomplete. It fails to explain crucial parameters like runId, rationale, or hypothesisId, and does not describe return values or error conditions.

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

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

With 0% schema description coverage, the description only adds meaning for the 'intent' parameter by listing allowed values. The other five parameters (runId, loop, newEpoch, rationale, hypothesisId) are left completely unexplained, which is insufficient for correct invocation.

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 supervisor decision hook for transition intents, listing allowed intents and explicitly stating what is refused. However, it does not directly differentiate from sibling tools like promotion_request or loop_next.

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

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

The description provides context for when to use the tool (worker proposing a transition requiring supervisor approval) and what intents are refused. However, it lacks explicit guidance on when not to use it or references to 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?

Describes exact execution behavior: launches 3-5 allowlisted workers via execFile, captures output, no model-supplied run-log. Also states what happens when opt-in is missing (returns BLOCKED). No annotations provided, so description fully covers 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?

Description is a single dense paragraph but front-loads key information and every sentence adds value. Could benefit from structure but remains clear and concise.

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 context on execution environment, opt-in, and alternatives, but lacks detail on return format and does not explain all parameters (runId, hypothesisId) thoroughly. Adequate given tool 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 coverage is 60% with descriptions for prompt, routes, and timeoutMs. The description adds context for routes (3-5 frontier worker routes) but does not explain runId or hypothesisId beyond what's in the schema. Adequate but not enhanced.

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's a supervisor-executed full test that launches frontier workers, distinguishing it from sibling tools like test_hypothesis which record run-logs without execution.

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

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

Explicitly states it's off by default with opt-in (env variable), and specifies alternatives (artifact_record + test_hypothesis) when exec is disabled. Also clarifies that failed launches don't count toward retirement.

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

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

With no annotations, the description carries the full burden. It states read-only behavior and refusal for held-out runs, but lacks details on authentication needs, rate limits, or output behavior (e.g., whether it saves a file or returns content). The information provided is adequate but not extensive.

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

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

The description is concise with three sentences, front-loading the main purpose and adding key details. No superfluous words, and it avoids repeating obvious information.

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

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

Given the tool has no output schema, the description should explain what the export returns (e.g., file path, success message). It only mentions the export format but omits the outcome. For two simple parameters, it is moderately complete but lacks output clarity.

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 50% (only outPath has a description). The tool description does not add meaning beyond the schema: runId is not explained, and outPath's description is already in schema. The description could have clarified the expected format or constraints for runId, but it does not.

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 exports a run's recorded tool trajectory in a specific format (Hermes-format JSONL) with details about content (one line per action, supervisor labels). It is specific and distinguishes from siblings by mentioning gate results and read-only behavior, though it doesn't explicitly compare to similar export tools.

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

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

The description gives some usage guidance: it is read-only and refuses gate-partitioned runs. However, it does not provide when to use this tool versus siblings like report_export or observation_record, nor does it mention prerequisites or typical scenarios.

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 fully discloses behavioral traits: filesystem stat only, no command execution, no arbitrary binary probing, not web/SOTA research, and caveat about auth. This is comprehensive and honest.

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

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

Three concise, front-loaded sentences. First sentence states purpose, second sets boundaries, third provides important limitation. Every word earns its place.

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

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

Given low complexity, no output schema, and full parameter coverage by schema, the description is complete. It covers purpose, constraints, and caveats, leaving no obvious gaps for an AI agent to misuse the tool.

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

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

The only parameter (runId) is fully described in the schema with 100% coverage; the description adds no further meaning. Baseline 3 is appropriate as the schema already documents it.

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

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

The description clearly states it provides a local capability report on installed frontier-agent CLIs and host profile, using specific verb 'report' and resource 'local capability'. It distinguishes itself from sibling tools like host_runtime_detect by focusing on CLI presence and host resolution without execution.

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 safe usage ('NEVER executes a command') but lacks explicit when/when-not guidance or naming of alternatives. It does not contrast with sibling tools like host_runtime_detect or other inspection 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 fully carries the burden of behavioral disclosure. It explicitly states the tool is read-only, never reads file contents, never mutates config, and returns a guess with evidence without auto-applying anything.

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, consisting of two sentences that front-load the purpose and efficiently cover all critical aspects without waste.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description is complete. It covers the purpose, behavior, output summary, and a key constraint (SUPER_LOOP_HOST). No gaps are evident.

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

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

Schema coverage is 100% for the single optional parameter 'runId', with its description as 'optional; only used to journal'. The tool description does not add further semantics beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: an advisory guess of the host runtime based on MCP config files. It uses specific verbs like 'detect' and 'guess', and distinguishes itself from siblings by emphasizing it does not read file contents or mutate config.

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 mentions that SUPER_LOOP_HOST is authoritative, providing some usage context. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or when-not scenarios.

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 discloses key behaviors: queuing, listing, no resolution, and non-blocking nature. However, it lacks details on error handling or side effects like ignoring notes/decision fields (though schema covers some of these).

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

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

Three sentences front-loaded with core purpose, no wasted words, efficiently conveys key guidance.

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

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

Covers purpose, usage, and key behavioral constraints. Lacks details on return values or what happens after queuing, but given no output schema and 6 parameters, the description is reasonably complete for an agent.

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

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

Schema coverage is 67%, so baseline is 3. The description does not elaborate on specific parameters beyond implying 'add' vs 'list' actions; it adds marginal value over the schema.

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

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

Clearly states the tool queues changes for human review or lists pending items, with specific verb-resource and differentiation from siblings like 'cannot resolve human review' and 'never blocks deterministic lanes'.

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

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

Explicitly states when to use (queue/list for dashboard) and when not to (approval/sludge is dashboard-only, does not block lanes), providing clear context for tool selection.

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

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

With no annotations, the description carries full burden. It discloses key behaviors: stores messages with sha256 hash, asks once, never asks again after initialization, operator remains stop condition, dashboard stays available. This is comprehensive but could mention idempotency or side effects more explicitly.

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 starts with a concise summary ('Ask-once gate') but then expands into a dense paragraph. While it is informative, the length could be slightly reduced by separating key points. Still, it remains focused and structured.

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

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

Given 7 parameters, nested objects, no output schema, and many siblings, the description provides enough context for usage. It explains the initialization flow, constraints, and operator involvement. Lacks details on return values or state persistence, but overall adequate.

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

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

Schema coverage is 86%, so baseline is 3. The description adds context (e.g., 'answers' are responses to ask-once questions, 'userMessages' stored and hashed), but the schema already covers most parameters. Additional value is moderate.

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

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

The description clearly states the tool's purpose: 'Ask-once gate. Confirms the task before any loop runs.' It explains the interaction flow (returns questions, then call again with answers), which distinguishes it from sibling tools like loop_start or continue_run that handle later stages.

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 (before a loop runs) and clarifies what the tool will not ask (model, promotion mode, etc.), guiding the agent on what inputs are relevant. While it does not explicitly name alternatives, the context of the workflow is clear.

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

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

No annotations provided, so the description must disclose behavioral traits. It states that only metadata is returned ('no full bodies'), which implies a read-only, non-destructive operation. However, it does not explicitly confirm that no side effects occur, nor does it mention any permissions or rate limits. The disclosure is partially adequate but could be more explicit.

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

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

The description is a single, well-structured sentence that front-loads the tool's purpose. Every word serves a function—defining scope, content, and limitations. No redundant or unnecessary 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?

For a simple list tool with one optional parameter and no output schema, the description covers the what and what-not. However, given the large sibling set, the lack of usage guidance leaves it slightly incomplete. The description would benefit from a brief recommendation on when to use this tool over, say, skill_fetch.

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

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

Schema coverage is 100% for the single optional parameter 'runId', and the schema already describes it as 'optional; only used to journal'. The description does not add any extra meaning beyond what the schema provides (e.g., when to supply runId). With high schema coverage, baseline 3 is appropriate.

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

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

Description clearly states the verb 'List', the resources 'every loop and skill', and the scope 'available to this local MCP'. It specifies what is included (mandated, custom loops, skills with metadata) and what is excluded ('no full bodies'). This effectively distinguishes it from sibling tools like loop_register or loop_start.

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 explicit guidance on when to use this tool vs. alternatives. With 27 sibling tools, including many that deal with loops and skills (e.g., loop_register, loop_next, skill_fetch), the description does not provide any comparison or context for selection. The agent receives no information about prerequisites or 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?

No behavioral traits are disclosed. The description does not mention side effects, permissions, rate limits, or any other behavioral aspects. With no annotations, this is insufficient.

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

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

The description is extremely concise but under-specified. It provides only an alias reference without substantive content, sacrificing usefulness 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?

The description does not cover output, behavior, or parameter details. For a tool with two parameters and no output schema, the description is incomplete and does not enable 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?

The description adds no meaning to the input schema. Neither 'loop' nor 'runId' are explained, and schema descriptions are absent. The tool fails to clarify parameter usage.

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

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

The description only says 'Alias of request_next_phase,' which does not directly state what the tool does. It relies on the user knowing another tool's purpose, making the purpose vague.

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 loop_next vs request_next_phase or other siblings. The description only indicates they are aliases without context.

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

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

With no annotations, the description must disclose behavioral traits. It reveals that loops are hashed, phase-gated, and streamed; skills are section-addressable with provenance-enforced frontmatter; overwriting is restricted for certain loops; and data does not leave the machine. This adds significant context beyond the schema, though details on streaming behavior could be richer.

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

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

The description is four sentences, succinct and well-structured. It front-loads the primary action, then details specifics about loops and skills, and ends with constraints. No unnecessary words or redundancy.

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

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

Despite 17 parameters and no output schema, the description covers the core behavior and two registration types. It explains hashing, phase-gating, provenance, and data privacy. It lacks details on expected return values or outcomes (e.g., how to invoke the registered loop/skill), but is fairly complete for the 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 94%, so most parameters are already described. The description adds value by explaining that 'content' holds full text, and clarifies the role distinction. However, it does not elaborate on many parameters like stack, tags, or anti_patterns beyond what's in the schema, so added meaning is moderate.

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 adds/registers loops or skills, with specific verb 'Add' / 'register' and resource types. It distinguishes between loops and skills and mentions constraints like 'Cannot overwrite hash-locked Strip Miner / Loop-de-loop'. This makes the purpose distinct from siblings like loop_library or skill_fetch.

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 explains the difference between loops and skills via the 'role' parameter, but does not explicitly tell when to use this tool versus alternatives (e.g., loop_library to list, or artifact_record for other data). Usage context is implied but lacks direct when-not-to-use guidance or comparison to 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, the description describes key behavior: activating the supervisor lane and returning only section 0. It does not detail side effects, idempotency, or state changes, but the disclosed behavior is sufficient for safe invocation.

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

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

The description is five sentences with no wasted words. It front-loads the main action, then provides examples and return behavior. Every sentence adds value.

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

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

While the description covers the main operation and return behavior, it does not explain the role of 'runId' or how this tool fits with siblings like loop_next. Given two required params and no output schema, the description is adequate but has 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 coverage is 50%: 'loop' has a description which the tool's description reinforces, but 'runId' lacks any description in schema or description. The description adds moderate value for 'loop' but does not fully compensate for the missing runId 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 clearly states the tool begins phase-gated streaming and opens/activates the supervisor lane for a loop. It specifies valid loop values like 'strip-miner' and 'loop-de-loop', distinguishing it from siblings like loop_next or loop_register.

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 examples of when to use the tool (e.g., 'Use strip-miner...') but does not explicitly compare with alternatives like loop_next or loop_register. It implies usage context but lacks explicit exclusion guidance.

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

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

No annotations provided, so the description carries the full burden. It reveals that the tool records lightweight evidence and is tied to phase gating, but does not disclose idempotency, side effects (e.g., whether it appends or overwrites), or what happens if called multiple times. Adequate but could be more detailed.

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

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

Two sentences, no wasted words. First sentence states purpose, second gives usage instruction. Highly concise and well-structured.

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

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

For a simple record tool with no output schema and no annotations, the description covers core purpose, key parameters, and the phase gate context. It lacks return value details and behavior on repeated calls, but is mostly complete given the tool's straightforward nature.

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

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

With 0% schema description coverage and 6 parameters, the description explicitly mentions 'loop' and 'phase' and implies 'runId' and 'summary' are needed. It does not explain 'kind' or 'sourceRef', leaving gaps. Adds meaning but incomplete.

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

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

The description clearly states the verb 'Record' and resource 'evidence' in the context of the current phase. It also adds outcome ('unlock the next section'), distinguishing it from siblings like 'artifact_record'.

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 explains it is for recording evidence to satisfy a phase gate and unlock the next section, providing clear context. It does not explicitly state when not to use or name alternatives, but the context is sufficient for appropriate selection.

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 provided; description discloses key behaviors: requires tool-measured reverified full test, blocks non-conforming results, and never overwrites canonical loop file. Could add details on idempotency or side effects.

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

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

Three sentences, each adding meaningful constraint or action. No wasted words, front-loaded with purpose and key requirements.

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

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

Covers what the tool does and its constraints well, but lacks parameter explanation and return behavior. No output schema; description does not mention what the agent gets back (e.g., success/failure, new champion ID).

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

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

Schema has 0% coverage; description does not explain runId or hypothesisId beyond names. With 0% coverage, description should define or provide context for parameters, but it does not.

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 'Request promotion of a hypothesis to internal champion' with specific verb and resource, and distinguishes from sibling tools like 'loop_next' and 'reverify_run' by detailing unique conditions.

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?

Describes when to use (hypothesis meeting strict criteria) and explicitly blocks old green unit tests without required metrics. Does not mention alternatives like 'reverify_run' or 'test_hypothesis' but context implies sequential use.

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 describes what the tool requires and rejects, but does not mention side effects, idempotency, or whether it is read-only or destructive. Partial disclosure is present.

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 with two sentences, front-loading the purpose and then adding constraints. Every sentence adds value without redundancy.

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

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

Despite the complexity of the input schema (array of objects with multiple fields), the description omits parameter details, return value, and error handling beyond rejections. It lacks completeness for a tool with many siblings and no output schema.

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

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

Schema description coverage is 0%, so the description must explain parameters. It mentions constraints on hypotheses (frontier routes, model exclusions) but does not explain the meaning of fields like 'tradeoff', 'falsifier', or 'operation' within the hypothesis object. The runId parameter is 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 clearly states the action 'register', the resource 'challenger hypotheses', and includes constraints on number (3–5) and route type. However, it does not differentiate from sibling tools like 'test_hypothesis' that also involve hypotheses.

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

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

Explicitly lists prerequisites ('baseline hash-lock + frozen benchmark + measured baseline bar') and rejection conditions ('<3 or >5, any haiku/mini/nano/lite/prior-gen route'), providing clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, description must fully disclose behavior. It says 'write' but omits side effects: does it overwrite? require permissions? fail silently? What is the run dir and what happens if it doesn't exist?

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?

Single sentence, no fluff, but the list of components is dense and could be clearer with bullet points or broken into separate sentences.

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

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

Lacks output schema and annotations; does not explain 'run dir' or the effect of format. For a tool with 24 siblings, this is insufficient for correct selection and invocation.

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

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

Schema coverage is 0%, and description does not explain either 'runId' or 'format'. The report contents are listed, but how parameters influence output is absent.

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 ('Write') and resource ('reproducible markdown report'), and lists concrete components (baseline lock, frozen benchmark, etc.), clearly distinguishing it from siblings like 'report_saturation'.

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 vs. the many siblings. Does not mention prerequisites, exclusions, or context like whether it is for final export vs. intermediate reporting.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It clearly explains that the supervisor auto-transitions, never pauses, awaits the operator only for stop conditions, and treats saturation as a pivot. This provides good context beyond the schema.

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

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

The description is four sentences, front-loaded with the main purpose. Each sentence adds useful context (auto-transition behavior, no pausing, operator as stop condition). It could be slightly more concise but is not overly verbose.

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

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

The description explains the tool's effect and behavior well, but it does not mention return values or side effects (e.g., confirmation of saturation report). Given the tool's complexity and lack of output schema, more detail on what happens after reporting would improve completeness.

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

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

Schema coverage is 50% (evidence has description, runId does not). The description mentions 'evidence-backed saturation' but does not add specifics about the runId or evidence parameter format or constraints. It does not compensate for the missing runId description.

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

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

The description clearly states the tool's purpose: informing the supervisor that a lane has reached evidence-backed saturation. It uses specific verbs and resources ('Tell the supervisor...') and implicitly distinguishes from siblings like loop_next by focusing on the saturation trigger. However, it does not explicitly differentiate from siblings.

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

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

The description implies when to use (when evidence-backed saturation is reached) and describes behavioral consequences (auto-transition). However, it lacks explicit guidance on when not to use this tool versus alternatives (e.g., reverify_run, loop_next) and does not state prerequisites or conditions.

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

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

No annotations are provided, so the description carries full burden. It discloses a blocking condition and rationale (prevents 300+ lines collapsing), but lacks detail on side effects, required permissions, or return format. The behavioral information is partial.

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

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

The description is concise with two sentences. It front-loads the action and provides a constraint. No wasted words, though the second sentence could be more structured.

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

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

Given no output schema, low schema coverage, and relatively complex behavior, the description is insufficient. It offers a high-level purpose and one constraint, but omits parameter explanations, error conditions, and return values. The agent cannot fully understand tool invocation requirements.

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 explain either parameter. The agent gets no guidance on what 'runId' or 'loop' mean, how they affect behavior, or valid values. This is a critical gap for a tool with undocumented parameters.

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

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

The description clearly states the tool streams the next loop section and provides a blocking condition. The verb 'stream' is specific, and the mention of 'BLOCKED (PHASE_SKIP)' clarifies the tool's behavior. However, it does not explicitly distinguish from sibling 'loop_next', so it loses a point.

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

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

The description indicates when the tool is blocked (unless current section has recorded evidence). This gives a usage condition but does not explicitly state alternatives or when not to use the tool. The guidance is implied rather than explicit.

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

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

With no annotations, the description carries full burden. It describes re-hashing artifacts and metric reproduction, and notes the consequence of blocking promotion. It does not mention authorization, rate limits, or potential side effects beyond verification.

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

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

Two concise sentences front-load the key term 'Deep re-verification' and efficiently convey purpose and consequence without extraneous details.

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

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

Given the 3 parameters and no output schema, the description fails to explain how parameters relate to the tool's operation. It does not define runId, testId, or hypothesisId, leaving the agent without guidance on what values to provide.

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

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

The input schema has 3 parameters with 0% description coverage, and the description does not explain any parameters. The agent must infer meaning from parameter names only (runId, testId, hypothesisId), which is insufficient for correct invocation.

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 performs deep re-verification by re-hashing raw artifacts and confirming metrics reproduce. It distinguishes from siblings like benchmark_run or test_hypothesis by focusing on verification rather than initial execution.

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

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

The description implies usage when promotion is needed after a test, noting that promotion is blocked until this passes. It provides context for anti-benchmark-gaming but does not explicitly exclude when not to use or list alternatives among 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 fully discloses behavior: the complete workflow, trust model (worker output never trusted, rejection reasons), safety cap (maxBatches), and a specific return value for missing private loops. This is comprehensive for a complex 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 dense with information and front-loads the key supervisor role and opt-in requirement. While it could be more structured (e.g., bullet points), it efficiently communicates a complex process in a single paragraph without waste.

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

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

Given the tool's high complexity and no output schema, the description covers workflow, trust model, and a specific error return. However, it lacks detail on successful return format or other possible error states, which is a gap for an agent to fully understand the tool's behavior.

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

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

Schema covers 3 of 4 parameters with descriptions. The tool description adds meaningful context beyond schema, e.g., warning that maxBatches is a safety cap not completion, and explaining stopFile as operator stop signal. However, it does not detail runId or the nested config structure further.

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 drives a full campaign autonomously, listing the detailed pipeline steps. It distinguishes from sibling tools like loop_next or reverify_run, which are individual steps, and explicitly mentions it's an 'AUTONOMOUS SUPERVISOR'.

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?

Mentions opt-in environment variable (SUPER_LOOP_ALLOW_EXEC=1) as a prerequisite and contrasts with the standalone CLI. Implicitly suggests use when full automation is desired, but does not explicitly state when not to use or list alternatives beyond the sibling list.

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

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

With no annotations, the description fully discloses behaviors: plan never loads full bodies, section fetches one section, partition defaults, and runId pins versions. No contradictions.

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 (under 100 words) and well-structured: starts with a clear verb+resource statement, then explains modes, parameters, and partitions without redundancy.

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

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

Given 7 parameters, two modes, and no output schema, the description covers key behavioral details (modes, partitions, version pinning) but omits the exact structure of returned data for section mode. Still, it is largely complete.

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

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

Despite 100% schema coverage, the description adds significant meaning beyond the schema: it explains the two modes, the purpose of each parameter in context (e.g., query for plan, skill_id for section), and default values.

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

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

The description explicitly states 'Retrieve skill knowledge for the current task' and distinguishes two modes (plan and section), making the tool's purpose clear and differentiating it from the listed sibling tools.

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

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

The description provides explicit guidance on when to use each mode: plan for reading the index to decide which sections to fetch, and section for fetching one section body. It also clarifies default and opt-in partitions.

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

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

The description discloses key behavioral rules: a no-improvement run must be recorded as NO_IMPROVEMENT (not 'perfect'), and failure counter is bumped. It also requires measurementRef. Without annotations, this provides important behavioral context beyond the schema.

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

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

The description is concise (two sentences) and front-loaded with the tool's purpose. It is efficient but could benefit from clearer structure or bullet points for parameter guidelines.

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 no output schema and no annotations, the description partially explains the test recording process but lacks details on return values, error handling, or how to properly structure the fullTest object. It is adequate but not fully complete.

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

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

Schema description coverage is 0% and the description does not explain the three required parameters (runId, hypothesisId, fullTest) beyond mentioning measurementRef. It adds some context about agentRuns but insufficiently compensates for the lack of 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 clearly states the tool records a 'full test of a hypothesis' involving 3-5 frontier agents. It adds specificity about agent runs requiring measurementRef. However, it doesn't explicitly differentiate from sibling tools like 'execute_full_test' or 'run_campaign', so purpose is clear but not uniquely distinguished.

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

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

The description implies usage when a full test is completed but does not provide explicit guidance on when to use this versus alternatives like loop_next or execute_full_test. No 'when not to use' or alternative references.

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

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

No annotations provided, so description carries full burden. Describes a read-only render operation, but tool name suggests write/update, creating inconsistency. Fails to disclose side effects, auth needs, or rate limits. The conflicting name undermines 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?

Single sentence efficiently conveys the main action and contents, but could be more structured. The list of dashboard components is concise and front-loaded.

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

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

Despite no output schema and one required parameter, the description fails to explain the runId parameter, and the name-action inconsistency adds confusion. The tool definition is insufficient for correct agent usage.

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

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

Single parameter 'runId' has no description in schema (0% coverage), and the description does not mention it at all, providing no guidance on its meaning or how to use it.

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

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

Clearly states it renders the local dashboard.html with specific contents like score matrix and phase progress, and implies a distinct role for human review. However, the tool name 'update_dashboard' contradicts the 'Render' verb, causing potential confusion about the tool's action.

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

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

Indirectly says 'human review happens only here; deterministic lanes do not wait on it', suggesting use when human review is needed, but does not explicitly state when to use this tool versus sibling tools like human_review_request or loop_next, nor mentions when not to use it.

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