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

With no annotations, the description must disclose behavioral traits. It mentions that baseline role hash-locks (write-once) and sourcePath reads are disabled, but does not discuss permissions, error handling, or whether the operation is idempotent beyond the baseline case.

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-loads the core purpose. It efficiently adds key details but could be better structured (e.g., bullet points) 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?

Given the complexity (10 parameters, nested objects, no output schema, no annotations), the description is incomplete. It does not explain many parameters, return values, or error conditions, leaving significant gaps for an agent to use correctly.

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

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

Schema coverage is low (20%), so description adds value. It explains the 'role' parameter's special behavior for baseline, the 'measurement' object's purpose, and the 'sourcePath' disablement. However, it doesn't explain all parameters like 'loop', 'newEpoch', or 'rationale'.

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 'Persist a raw artifact with a sha256 hash', specifying the action and resource. It distinguishes the tool by mentioning role constraints and measurementRef, but does not explicitly differentiate from siblings like 'observation_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 provides usage hints: role baseline is write-once, sourcePath is disabled, and measurement should be passed. However, it lacks direct guidance on when to use this tool versus alternatives or when not to use it.

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

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

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 exist, so the description must disclose behavior. It mentions rejection of invalid proposals but omits what happens on success, side effects, authorization needs, or output format. This leaves significant gaps about tool 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, information-dense sentence that front-loads the main purpose. It avoids fluff but could be slightly more structured for readability. Still, it is appropriately sized for a simple tool.

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

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

Given no output schema, no annotations, and a complex nested input schema, the description should provide more context about return values, state changes, and integration with sibling tools. It only covers input validation criteria, leaving the overall workflow 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 description coverage is 0%, so the description must explain parameters. It partially explains the 'benchmarks' parameter by listing required fields, but does not clarify the 'runId' parameter or the exact semantics of fields like 'oracle' or 'qualityScale'. Two parameters remain under-documented.

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

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

The description clearly states the tool's action: 'Propose one or more benchmark scorecards built from real prior uses/failures.' It specifies the resource (benchmark scorecards) and distinguishes from siblings like benchmark_run or benchmark_freeze_maker by focusing on the proposal phase.

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 validation criteria: each benchmark must have ≥1 task-value dimension, ≥1 resource/cost dimension, and ≥1 concrete case, otherwise rejected. This guides proper usage but does not contrast with when to use alternatives like benchmark_select or benchmark_freeze_maker.

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 records a run, that baseline sets a benchmark, and disallows model self-reports as measurementRef. However, it does not mention side effects, permissions, or whether the operation is read-only or destructive, leaving gaps in behavioral 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 two sentences with no fluff. The first sentence immediately states the purpose, and the second adds essential nuance. Every word earns its place, making it highly efficient.

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

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

For a tool with three required parameters, no output schema, and no annotations, the description covers the core idea but leaves out what constitutes a 'run', the nature of the 'frozen benchmark', and how hypothesis arms beyond 'baseline' are used. Additional detail on return values or side effects 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 only 33% (only `arm` has a description). The description adds meaning for `arm` (baseline sets the bar) and `measurementRef` (must be a recorded raw artifact), but provides no additional info for `runId`. This partially compensates for the low schema coverage but is not comprehensive.

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 ('Record') and resource ('a tool-measured run of an arm through the frozen benchmark'), clearly distinguishing it from sibling tools like `benchmark_propose` or `benchmark_select`. The phrase 'tool-measured' and 'frozen benchmark' add precision.

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

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

The description explicitly states when to use 'baseline' as the arm and that `measurementRef` must be a recorded raw artifact, not a model self-report. This provides clear context for appropriate usage, though it does not explicitly list when-not conditions or compare directly with all 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?

Without annotations, the description discloses key behaviors: the operation freezes the benchmark (making it immutable), requires a prior hash-lock, and outlines the effort needed to change. No contradictions with annotations as none are provided.

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 with no redundancy. The first sentence states the core action, the second adds essential constraints. Perfectly front-loaded 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?

Given 4 parameters, no output schema, and no annotations, the description covers the core intent and key constraints but lacks parameter details and success/failure behavior. 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?

The input schema has 4 parameters with 0% description coverage. The description only mentions 'baseline' and 'new epoch + rationale' but does not map them to runId, benchmarkId, newEpoch, or rationale. This leaves the agent with insufficient understanding of each parameter's role.

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 'Freeze ONE proposed benchmark as the immutable scorecard for this cycle', using a specific verb and resource. It distinguishes from sibling tools like benchmark_propose and benchmark_freeze_maker by implying the tool is for finalizing after proposal.

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 a prerequisite ('Requires the baseline to be hash-locked first') and consequence ('Changing a frozen benchmark needs a new epoch + rationale'), but does not explicitly list alternatives or when-not-to-use 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?

The description discloses the read-only nature and a key behavioral detail ('Pending review never blocks the campaign'). However, with no annotations, it lacks information about authorization needs, return format, or potential side effects.

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

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

The description is a single sentence that conveys purpose and key details, though it is somewhat long due to listing components. It is front-loaded with the main intent ('Read-only supervisor status').

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 low complexity (one parameter, no output schema), the description provides a reasonable enumeration of status components. However, it is incomplete without explaining the output format or pagination, leaving some gaps.

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

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

The single parameter 'runId' is not described in the input schema (0% coverage) and the tool description does not explain what it represents or how to obtain it. This leaves ambiguity for the agent.

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

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

The description clearly states it provides 'Read-only supervisor status' and enumerates specific components like lane/target queue and dashboard review items. However, it does not explicitly state the verb-resource relationship (e.g., 'retrieve status'), which slightly reduces clarity.

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

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

No explicit guidance on when to use this tool versus alternatives like 'update_dashboard' or 'run_campaign'. The description implies read-only use but does not specify when it is appropriate or when to avoid it.

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

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

With no annotations, the description carries full burden and discloses key behaviors: it never asks the user, never marks campaign complete, and does not clear continuation obligation. Could mention side effects of recording.

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 purpose, and the second provides critical behavioral 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?

Explains workflow context (after reports, etc.) and limitations. No output schema, but return values are not critical for a recording tool. Sibling tools are many but role is clear.

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%, and the main description does not add detail for runId or rationale. It briefly clarifies lane and firstAction but relies heavily on 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 it records the next runnable improvement lane and first concrete action, and distinguishes from siblings by noting it never asks the user, never marks campaign complete, and does not clear continuation obligation.

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

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

It explicitly states when to use (after reports, dashboards, etc.) and when not to use (does not clear continuation obligation; a real progress tool must run next), but does not name alternative tools.

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

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

With no annotations provided, the description carries the full burden. It reveals that only supervisor-accepted transitions count as progress, that reasoning alone is never proof, and that completion/stop intents are refused. However, it lacks details on authorization requirements, rate limits, side effects (e.g., whether previous transitions are invalidated), and what happens after submission (e.g., blocking vs. async).

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 four sentences. The first sentence immediately provides the core purpose and context (supervisor decision hook). Subsequent sentences add useful detail about allowed/disallowed intents. No redundant information, though the phrase 'reasoning alone is never proof' adds behavioral nuance but is slightly tangential.

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

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

Given the absence of annotations, output schema, and parameter descriptions, the description is insufficiently complete. It partially explains the intent parameter but ignores the other four parameters. It does not describe return values or error conditions, leaving the agent to guess the full interaction flow for a tool with 6 parameters and critical behavioral implications.

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 adds meaning to the 'intent' parameter by listing allowed values (promote, advance_phase, etc.) and disallowed ones (completion/stop). However, parameters like runId, loop, newEpoch, rationale, and hypothesisId are not explained at all, leaving the transition packet concept vague and the agent without guidance on what to fill.

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

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

The description clearly states the tool is the supervisor decision hook for transition packets, listing specific allowed intents (promote, advance_phase, etc.) and disallowed ones (completion/stop). This distinguishes it from sibling tools like promotion_request or request_next_phase by making the supervisor-approval requirement explicit.

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

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

The description explicitly defines when to use this tool (proposing a transition needing supervisor acceptance) and when not to (completion/stop intents are refused). It provides a list of allowed intents and states that reasoning alone is insufficient, but does not name alternative sibling tools for the refused intents, only noting that the operator is the stop condition.

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. It details that the tool launches 3-5 allowlisted workers via execFile (never a shell), captures each output, feeds through the same gate as test_hypothesis to prevent fabrication, and that failed/timed-out/non-allowlisted launches are invalid and don't count toward retirement.

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 paragraph of about 5 sentences, reasonably concise. It could benefit from bullet points for the behavioral details, but it is well-structured and front-loaded with the key purpose.

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

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

No output schema exists. The description mentions capturing output and feeding through test_hypothesis gate, but does not describe the return value format. Given the tool's complexity, this is a notable gap. However, it covers execution flow, worker launching, and error handling well.

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 60% (3 of 5 params described). The description does not add extra meaning for the undocumented parameters (runId, hypothesisId) beyond what the schema provides. Baseline 3 is appropriate as schema already covers some parameters adequately, but description does not compensate for the gap.

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

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

The description clearly states it is a 'SUPERVISOR-EXECUTED full test' that launches frontier workers, captures output, and gates through test_hypothesis. It distinguishes from siblings by mentioning alternative tools (artifact_record, test_hypothesis) and the opt-in requirement.

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 the tool is off by default with opt-in via env SUPER_LOOP_ALLOW_EXEC=1, and provides a clear alternative: 'Without the opt-in this returns BLOCKED (EXEC_DISABLED) and you record run-logs via artifact_record + test_hypothesis instead.'

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

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

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 behavior: filesystem stat only, no execution, no arbitrary probing, not for web/research. Also notes that PATH presence does not guarantee working auth, adding important caution.

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 focused sentences plus a one-line caution. Every sentence provides essential information. No fluff, well-organized.

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?

Output is not described explicitly, but the nature of the report is implied. Given no output schema, a hint about the format would improve completeness, but the description is sufficient for a preflight check 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?

Only one optional parameter (runId) with schema description 'optional; only used to journal'. The description adds little beyond the schema, but the overall context of the tool is well explained. Baseline 3 due to 100% schema coverage.

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

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

Description clearly states the tool reports local capability (installed CLIs) and resolved host profile. Uses specific verbs and resources, distinguishing it from sibling tools like host_runtime_detect or benchmark 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?

Explicitly states it never executes commands, never probes arbitrary binaries, and is not web/SOTA research. This helps an agent avoid misuse. Does not mention alternatives directly, but the negatives provide clear when-not-to-use guidance.

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

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

With no annotations, the description fully carries the burden. It explicitly states the tool is READ-ONLY, never reads file contents, never mutates config, and does not auto-apply anything. This provides complete behavioral transparency.

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

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

Three sentences: tool purpose, behavioral constraints, output summary. Every sentence adds essential information, no redundancy or fluff. Front-loaded with the key action.

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, the description details the return value (guess, candidate hosts with evidence, CLI fallback) and the authoritative flag. The tool's complexity is low, and the description covers all necessary aspects for an agent to invoke and interpret 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 coverage is 100% with a description for runId. The description adds the context that runId is 'only used to journal', clarifying its optional, non-functional purpose beyond what the schema states. This adds meaningful 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 clearly states the tool performs an advisory guess of the host runtime based on MCP config files, with a specific verb ('detect') and resource ('host runtime'). It is distinct from all listed sibling tools, which cover recording, benchmarking, execution, etc.

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

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

The description implies the tool is used for detecting the host runtime and notes that SUPER_LOOP_HOST is authoritative, but does not explicitly state when to use or avoid this tool compared to alternatives. No direct alternatives exist among siblings, so guidance is adequate but not 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?

Without annotations, the description carries the full burden. It discloses that the tool does not resolve human review, is non-blocking, and that certain params like notes and decision are ignored/refused. Could add more detail on side effects or state changes, but current info is useful.

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 action, followed by crucial constraints. Every sentence provides unique value with no redundancy. Efficient and well-structured.

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

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

Given 6 parameters (including nested objects) and no output schema or annotations, the description covers the essential context: purpose, constraints, and behavioral guarantees. It doesn't detail return values (acceptable without output schema) but is sufficient for an agent to select and use correctly.

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

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

Schema coverage is 67% with some param descriptions. The description adds value by clarifying that notes and decision are ignored/refused, and reviewId only accepted for legacy resolve attempts. This compensates for missing schema descriptions and helps the agent understand parameter intent.

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

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

The description clearly states the tool's purpose with specific verbs ('queue', 'list') and resource ('operator's Approve/Sludge dashboard'). It distinguishes from siblings by explicitly stating what it cannot do (resolve human review) and that it never blocks deterministic lanes, differentiating it from other review/decision 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?

Provides explicit when-to-use (queue or list human review items) and when-not-to-use (CANNOT resolve, approval/sludge is dashboard-only). Also includes context: never blocks deterministic lanes, loop keeps running. This gives clear guidance to the agent on appropriate invocation.

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

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

Discloses that user messages are stored locally with sha256 hash, that after initialization it does not ask again or mark the campaign complete, and that the operator remains the stop condition. Also covers the conditional behavior based on underspecification. No contradictions since no annotations are provided.

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

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

The description is dense but well front-loaded with the core purpose. Each sentence adds value, covering behavior, usage, and constraints. Slightly lengthy but justified by the tool's complexity.

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

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

Given the tool's role as a gate, the description covers the initialization phase thoroughly, including what it returns when underspecified and how to proceed. Lacks detail on return value after answers and error handling, but overall sufficient for an agent to use 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 high (86%), so the baseline is 3. The description adds some context (e.g., 'answers' correspond to the ask-once questions), but does not significantly enhance parameter understanding beyond the schema's 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?

Clearly identifies the tool as an 'Ask-once gate' that confirms the task before loops run. It describes its role of prompting for underspecified tasks and then accepting answers to begin. Distinct from sibling tools like 'loop_start' and 'continue_run', which 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?

Explains the two-phase usage: first call with 'task' to receive questions, then call with 'answers' to begin. Also clarifies what the tool never asks (model, promotion mode, etc.), indicating the supervisor's role. Lacks explicit statement of when not to use or comparison to alternatives.

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

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

No annotations 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 annotations provided, and the description only states it is an alias. No disclosure of effects, auth needs, or other behaviors.

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 short but fails to provide essential information. It is under-specified, so it does not earn its place.

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

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

Given two parameters, no output schema, and no annotations, the description is wholly inadequate. It does not cover return values, behavior, or parameter 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 coverage is 0%, and the description does not explain the purpose or format of the 'loop' or 'runId' parameters. No value added beyond the schema.

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

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

The description says it is an alias of request_next_phase, but does not explain what that tool does. The name 'loop_next' suggests looping, but the purpose is vague and relies on knowledge of another tool.

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 alternatives. The sibling list includes request_next_phase, but the description gives no context for choosing between them.

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

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

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 discloses that the tool opens/activates a supervisor lane and returns only section 0, but lacks details on side effects, destructiveness, authentication needs, or 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?

Three sentences that are front-loaded with the primary action, include examples, and contain no unnecessary words. Highly 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?

Adequate for a simple tool, but lacks explanation of 'phase-gated streaming' and 'supervisor lane,' and no discussion of prerequisites or error handling. With no output schema, more context on return values would be helpful.

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?

Adds value for the 'loop' parameter by giving concrete examples and mentioning registration with loop_register, but the 'runId' parameter is not described. Schema coverage is 50%, so description partially compensates.

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 'Begin phase-gated streaming' with specific verb and resource, lists valid loop names, and distinguishes itself by noting it returns only section 0, which differentiates from siblings like loop_next and 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?

Provides explicit examples of when to use this tool (e.g., starting 'strip-miner' or 'loop-de-loop') and notes that it returns only section 0, implying for other sections use different tools. However, no explicit when-not-to-use or alternative tool names.

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 fully disclose behavioral traits. It mentions that attaching 'loop' and 'phase' 'unlock[s] the next section', implying a side effect beyond recording. However, it does not explain if the tool is idempotent, requires specific permissions, or what the return value looks like. It lacks detail on the nature of the evidence recording (append, overwrite, etc.).

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

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

The description is only two sentences long, with the main purpose front-loaded in the first sentence. The second sentence adds critical usage context about the phase gate. No extraneous information is present. Every sentence 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 the tool has 6 parameters with no schema descriptions, no output schema, and no annotations, the description partially compensates by explaining the purpose and the phase-gate unlock mechanism. However, it omits details on return values, parameter formats, and error conditions. For a moderately complex tool, this leaves gaps.

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

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

The input schema has 6 parameters with 0% description coverage. The description only mentions 'loop' and 'phase' in the context of satisfying the phase gate, but does not explain their types, allowed values, or how they map to schema properties. Parameters like 'kind', 'sourceRef', and 'runId' are entirely undocumented in the description, leaving the agent to rely solely on the schema names.

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

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

The description clearly states 'Record lightweight evidence for the current phase', specifying the verb 'Record' and the resource 'evidence'. It also mentions 'what you actually did/observed', which further clarifies the tool's function. This distinguishes it from siblings like 'artifact_record' which likely records artifacts, and 'register_hypotheses' which records 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?

The description indicates when to use the tool: 'for the current phase' and to 'satisfy the phase gate and unlock the next section'. It provides clear context of use, but does not explicitly state when not to use it or mention alternative tools. However, the phase-gate requirement is a strong guideline.

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 full burden for behavioral disclosure. It reveals important constraints: blocking certain inputs and never overwriting a file. However, it does not describe failure modes, success effects, or whether the tool creates or modifies resources beyond promotion status. This is adequate but 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 three sentences, each serving a purpose: stating action, listing requirements, noting a constraint. It is relatively concise with no redundancy. However, it could be more tightly structured by grouping conditions before behaviors, but overall it is efficient.

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

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

Given the tool has 2 required parameters with no schema descriptions, no output schema, and no annotations, the description covers purpose and prerequisites but lacks parameter explanations and return value information. It is moderately complete for a promotion request tool but would benefit from explaining what happens on success or failure.

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. However, it does not explain what 'runId' or 'hypothesisId' represent or how they relate to the precondition (e.g., which run or hypothesis is being promoted). The description adds no parameter-specific semantics beyond the purpose.

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: 'Request promotion of a hypothesis to internal champion.' It specifies the required condition (tool-measured, reverified full test on frozen benchmark pushing the frontier past threshold) and distinguishes itself by blocking old green unit tests without score matrix, ensuring the tool is used for a specific, high-quality promotion scenario.

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

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

The description provides clear when-to-use guidance by listing prerequisites (specific test type and result threshold) and exclusions (old green unit tests, model-reported metrics, below-threshold results). It also notes it never overwrites the operator's canonical loop file. While it doesn't explicitly name alternative tools, the context of sibling tools and the clear conditions make usage guidelines effective.

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 behavioral constraints on count and route validation but does not describe side effects, auth needs, or what happens upon successful registration. The rejection criteria are helpful but incomplete for 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 two sentences with no redundancy. It front-loads the core action and constraints, making it efficient and easy to parse.

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

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

Given no output schema and low schema coverage, the description lacks important context: it does not explain what 'challenger hypotheses' or 'frontier route' mean, nor does it describe the outcome or return value. The prerequisites are listed but not elaborated.

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

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

Schema description coverage is 0%, meaning the description must compensate but fails to explain individual parameters like title, tradeoff, or falsifier. It only adds context about the count and route of hypotheses, leaving the meaning of other fields unclear.

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

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

The description uses a specific verb 'Register' and identifies the resource 'challenger hypotheses on frontier routes'. It clearly distinguishes this tool from siblings by specifying count constraints (3-5) and route restrictions (no haiku/mini/nano/lite/prior-gen), setting it apart from other hypothesis-related tools.

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

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

The description explicitly states prerequisites (baseline hash-lock, frozen benchmark, measured baseline bar) and rejection conditions (<3 or >5 hypotheses, disallowed routes). Although it does not name alternative tools for different scenarios, the guidance is clear on when to use and what is required.

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 behavior fully. It mentions 'write' and 'reproducible' but lacks details on side effects (e.g., overwrite), required run state, permissions, or return value.

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 with a parenthetical list is concise. Could be more structured (e.g., key points first), but 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 no annotations or output schema, and complex sibling context, the description lacks important details like prerequisites, output location specifics, and relationship to other report tools.

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

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

Schema coverage is 0%, yet the description does not explain either parameter. 'runId' and 'format' are left undefined, and the format parameter's purpose is unclear given the description already specifies markdown.

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 writes a reproducible markdown report to the run dir and enumerates the contents (baseline lock, frozen benchmark, etc.). However, it does not differentiate from sibling tools 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 versus alternatives such as report_saturation or artifact_record. The description does not provide 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 discloses key behaviors: auto-transition, no pausing, operator as only stop condition. It does not mention error handling or side effects, but for a reporting tool this is sufficient.

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

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

Four sentences, each adding essential information. Front-loaded with purpose, followed by behavioral details. No redundant or vague statements.

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 reporting tool with no output schema, the description covers purpose, effect, and stopping conditions. It could mention return value or confirmation, but it is acceptable given the 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 50% (evidence parameter has a description, runId does not). The tool description does not add any parameter-specific details beyond the schema, so it fails to 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 reports saturation for a lane and triggers an automatic transition. It uses specific terms like 'lane' and 'saturation', but does not explicitly differentiate from sibling tools like 'loop_next' or 'cycle_decision_request'.

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 saturation is reached, and explains the automatic behavior and operator stop condition. However, it does not explicitly state when not to use this tool or mention alternatives.

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

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

With no annotations, the description carries the full burden. It discloses the blocking behavior, the reason behind it (prevent context collapse), and the streaming nature. This goes beyond a simple action statement, though it could mention side effects or idempotency.

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

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

The description is three sentences that each add unique value: action, condition, and rationale. It is front-loaded with the action and concise without 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 no output schema and 2 undocumented parameters, the description lacks important context such as return format, when exactly to call (beyond evidence requirement), and parameter roles. It covers the core behavior but leaves gaps for a new user to understand full 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?

The input schema has 2 parameters with 0% description coverage, and the description does not mention any parameter meaning or usage. Without compensation, the description adds no value for parameter understanding.

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

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

The description clearly states that the tool streams the next loop section, with a specific blocking condition (PHASE_SKIP unless evidence recorded). It distinguishes from sibling tools like 'loop_next' by highlighting the blocking behavior and the motivation to prevent large context collapses.

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

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

The description implies usage by noting the blocking condition (requires recorded evidence), but does not explicitly compare to alternatives or state when not to use it. The context about preventing 300+ lines gives some guidance, but it is not explicit enough for clear alternative choice.

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 mentions the verification process and the consequence (blocking promotion), but does not disclose side effects, idempotency, or whether it modifies state. The behavior is partially transparent but lacks depth.

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

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

The description is extremely concise with two sentences. The first sentence front-loads the action and the second adds consequence and motivation. Every word earns its place with no redundancy.

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

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

The description covers purpose and consequence but fails to document parameters, which are essential for a tool with 3 params and no output schema. Given the complexity and lack of annotations, the description is incomplete.

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

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

Schema description coverage is 0% and the description does not explain any of the three parameters (runId, testId, hypothesisId). The required runId is not mentioned, and optional parameters are ignored. This is a critical gap 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 the tool's purpose: 'deep re-verification' by re-hashing raw artifacts and confirming metrics. It distinguishes itself from sibling tools by explicitly linking to promotion blocking and anti-gaming, which is a unique use case.

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

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

The description implies when to use this tool: before promotion ('promotion is blocked until this passes'). It provides context (anti-benchmark gaming) but does not explicitly state when not to use it or compare to alternatives like test_hypothesis.

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 transparently details rejection criteria (summary-only, early-stop, fake-metric, etc.), validation process, and the return value for missing loops. This far exceeds minimal disclosure.

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

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

The description is a dense wall of text without bullet points or structure. While it front-loads the key 'AUTONOMOUS SUPERVISOR' label, the rest is a long sentence that could be broken into multiple sentences or lists 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?

Given the complexity of the tool and lack of output schema, the description covers the workflow, safety caps, validation, and return behavior. It is fairly complete, though a bit verbose.

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 75% (3 of 4 params have descriptions). The tool description reiterates the purpose of maxBatches and stopFile but does not add new semantic details beyond the schema. Config parameter is described with a nested structure in the schema, and the description gives some context but no additional clarity.

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

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

The description clearly states the tool's purpose as an 'AUTONOMOUS SUPERVISOR' that drives a whole campaign end-to-end, listing specific phases (intake, work queue, mine/improve, etc.). It distinguishes itself from sibling tools like campaign_status or continue_run by being the main orchestrator.

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 includes opt-in condition (SUPER_LOOP_ALLOW_EXEC=1) and distinguishes between the in-call MCP run (bounded by maxBatches) and the standalone CLI. It does not explicitly list when not to use this tool relative to siblings, but provides clear context for when it 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, 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?

With no annotations, the description carries full burden. It reveals some behavioral traits (e.g., outcome values like NO_IMPROVEMENT, never 'perfect'), but does not disclose side effects, idempotency, or behavior on repeated calls. Missing transparency on what happens after recording (e.g., aggregation, state updates).

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, stating the main action in the first sentence. Additional clarifications about agent runs and outcome rules are useful. However, it could be better structured (e.g., separate sections for input-output 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 the complexity (nested objects, 3 required params, no output schema), the description is insufficient. It does not explain what the tool returns, how to construct the fullTest object, or what constitutes valid inputs beyond the mention of measurementRef. An agent would likely need additional information to use this tool correctly.

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

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

Schema coverage is 0%, requiring description to compensate. The description adds meaning to 'measurementRef' (must be tool-measured) and outcome classification, but does not explain 'runId', 'hypothesisId', or the full structure of 'fullTest' (e.g., valid values for 'model'). Incomplete parameter semantics.

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

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

The description clearly defines the tool's purpose: recording a full test of a hypothesis involving 3–5 frontier agents, with specific requirements for measurement references and outcome classification. It is distinct from sibling tools like 'execute_full_test' or 'observation_record' due to the explicit mention of agent runs and baseline comparison.

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 versus alternatives (e.g., 'execute_full_test' or 'observation_record'). The description only explains what it does, not the context of use, prerequisites, or when not to use it.

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

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

No annotations are provided, so the description carries the burden. It says 'render' implying read-only, but the name suggests mutation. It does not explicitly state whether the tool modifies state or is safe.

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 action. However, it could be more precise about the parameter.

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

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

With one required parameter and no output schema, the description should explain the role of 'runId'. It lists dashboard contents but omits how the parameter fits in, making it 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 coverage is 0% and the description does not mention the 'runId' parameter at all, leaving its purpose and format completely unspecified.

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 renders a local dashboard, but the name 'update_dashboard' suggests modification, creating confusion. It does not explicitly distinguish from sibling tools.

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

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

The description provides context that human review happens here and deterministic lanes do not wait, but it does not name alternatives or specify when to use this tool versus others.

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