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

All annotation hints are false, providing no safety signals. The description adds a key behavioral trait: 'make cancellation terminal,' implying irreversibility. However, it does not disclose side effects, required permissions, or consequences beyond that, so it only partially carries the burden.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise but minimal, and could be expanded with more useful context without losing its efficiency.

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 three required parameters, an output schema, and a large sibling toolset, the description is insufficient. It lacks usage guidelines, parameter semantics, and outcome details beyond 'terminal,' making it difficult for an agent to understand the cancellation workflow and when to invoke this tool.

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

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

The schema has 0% description coverage for the three required parameters (run_id, expected_revision, host_receipt_id). The description does not mention or explain any of these parameters, leaving the agent without semantic context for what they mean or how they relate to the operation.

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 ('acknowledge') and resource ('host interruption') and states the effect ('make cancellation terminal'). This clearly distinguishes it from sibling tools like request_run_cancellation and pause_host_run, though it could elaborate on what 'terminal' means.

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

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

The description implies usage in the context of a host interruption acknowledgment, but it does not explicitly state when to use it versus alternatives, nor does it provide exclusions or prerequisites. With 25 siblings, only implicit guidance is given.

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?

Annotations already indicate a write operation (readOnlyHint false). The description adds behavioral context by noting it excludes prompts, raw arguments, or credentials, implying sanitization or rejection. However, it doesn't explain what happens if such content is provided or the role of expected_revision.

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 clean sentence, no fluff, front-loaded with the verb and resource. Highly 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?

The description leaves critical gaps: parameter meanings (expected_revision), the shape and constraints of receipts, and behavior when constraints are violated. Given the tool has three required parameters and an output schema, this is insufficient for an agent to invoke it correctly.

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

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

Schema has 0% description coverage, and the description provides no parameter semantics. run_id, receipts, and expected_revision are unexplained, especially expected_revision's purpose (likely concurrency control) and the structure of receipts items.

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 ('append') and resource ('safe live stage/tool receipts'), making the action clear. It distinguishes from siblings by emphasizing 'safe' and the exclusion of prompts/raw arguments/credentials, though it doesn't name a specific alternative.

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

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

No guidance is provided on when to use this tool versus other run-related tools like commit_host_stage or finalize_host_run. The only implied context is appending receipts, with no explicit exclusions or alternatives.

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

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

Annotations already indicate this is not read-only, not idempotent, and not destructive. The description adds that it 'checkpoints' and 'returns the next stage,' giving some behavioral insight. However, it does not disclose important side effects like revision conflict handling or whether the operation persists immediately. With annotations covering the basic mutation profile, this is adequate but not rich.

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

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

A single sentence that is front-loaded with the core action and includes the return behavior. No wasted words or filler, and it is appropriately brief for the tool's complexity.

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

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

The tool has 5 parameters, no parameter descriptions, and no usage prerequisites. Critical context is missing: what state the host must be in, how to obtain expected_revision, what happens on conflict, and how the returned next stage should be used. The output schema exists, so return type is structurally documented, but the operational context is seriously incomplete for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain run_id, stage_id, output, expected_revision, or attempt. The names are somewhat self-descriptive, and 'completed host stage' hints at stage_id, but no details are provided for expected_revision's concurrency role or attempt's purpose. This is insufficient for a 5-parameter mutation tool.

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

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

The description clearly states the verb 'Commit and checkpoint' and the resource 'one completed host stage', with an explicit result: 'return the next stage.' This distinguishes it from sibling tools like finalize_host_run (whole run) and start_host_run (initial stage).

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

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

The phrase 'one completed host stage' implies it should be used after a stage is finished and before proceeding to the next. It provides clear context for when to invoke, though it does not explicitly name alternatives or exclusion scenarios. No misleading 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?

Annotations are sparse (all false), so the description carries some burden. It adds valuable context like 'durable' and 'credential-free', which signal persistence and lack of authentication needs. However, it does not disclose side effects, return values, or behavior on existing runs, despite the output schema existing.

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

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

The description is a single, concise sentence with no wasted words. It front-loads the action and key attributes, making it easy to scan and understand.

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 (8 parameters, many sibling tools, output schema), the description is too minimal. It does not explain the tool's role in the broader workflow, how it differs from similar tools, or what the output schema represents, leaving the agent under-informed.

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

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

Schema description coverage is 0%, and the description mentions no parameters. Although the schema has 8 parameters with clear names, the description fails to explain their purpose or relationship to the tool's behavior, leaving the agent to infer from names 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 action (Create) and the resource (host run), with distinguishing qualities ('durable', 'credential-free', 'decision-memory recall'). However, it does not explicitly differentiate from sibling tools like 'prepare_host_run' or 'start_host_run', which may cause some ambiguity about the exact stage in the workflow.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools covering host run lifecycle steps, the agent lacks clear decision rules for selecting 'create_host_run' over 'prepare_host_run' or 'start_host_run'.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe, idempotent nature is known. The description adds the specific scope of discovery (executors, tools, safety boundaries, default fixture) but does not disclose additional behaviors such as return format or cost.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently conveys the tool's purpose.

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

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

For a parameterless tool with an output schema, the description is sufficiently complete to inform an agent of the tool's purpose. It lacks an explicit 'use this first' hint, but the tool name and description are adequate.

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

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

The schema has zero parameters, so there is nothing to document. The description appropriately omits parameter details, and the baseline of 4 applies.

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

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

The description uses the specific verb 'Discover' and lists distinct resources (executors, tools, safety boundaries, default fixture), making the tool's function clear. However, it doesn't explicitly differentiate from sibling tools like get_feature_matrix, which could also be used for discovery.

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

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

No usage guidance or alternative tool references are provided. The description gives no context on when to call this tool versus others, which is a gap given the large sibling toolset.

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?

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds valuable context about atomicity and crash-recoverability, explaining meaningful behavioral traits beyond the structured annotations. This helps the agent understand retry safety and consistency guarantees.

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

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

A single sentence that begins with the verb and packs in detail without filler. Every clause earns its place, and the technical terms are dense but purposeful.

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 omits parameter semantics, usage context, and any mention of the output schema, though the output schema exists. For a destructive tool with three parameters, this is insufficiently complete for an agent to invoke it correctly without additional inference.

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

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

Schema coverage is 0%, and the description does not explain run_id, destination, or overwrite. The phrase 'validated overwrite' hints at the overwrite parameter, but this is indirect and does not compensate for the missing parameter-level 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 identifies the action 'Export' and the object 'a bundle', which is a distinct operation not present among sibling tools. The behavioral qualifiers (atomic, crash-recoverable) do not obscure the core purpose.

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

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

No guidance is provided on when to use this tool versus alternatives like get_run_result or finalize_host_run. The description focuses on how the export works mechanically but never states scenarios, exclusions, or prerequisites.

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

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

The description adds meaningful behavior: validation and atomic publication. Annotations are all false and provide little context, so the description carries the burden. It does not disclose side effects, failure behavior, or whether publication is irreversible, leaving gaps.

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

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

Single sentence with no filler, front-loaded with the main actions. It is concise 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?

For a finalization step in a complex lifecycle, the description is too terse. It omits prerequisites beyond committed stages, consequences of publishing (e.g., immutability), and error semantics. The output schema exists but does not compensate for missing behavioral context.

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

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

Schema description coverage is 0%, and the description does not mention parameters. run_id is self-explanatory, but expected_revision's purpose is unclear (e.g., optimistic locking, expected state). The description fails to compensate for the schema's lack of parameter explanations.

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

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

The description clearly identifies the action ('validate' and 'atomically publish') and the resources ('all committed stages', 'completed dossier'). It distinguishes this tool from siblings like commit_host_stage and export_completed_run by indicating it is the finalization step.

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

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

The description implies usage after stages are committed ('Validate all committed stages'), providing clear context. However, it does not explicitly name alternatives or exclusions, which would elevate it to a 5.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool is known to be non-mutating. The description adds the behavioral nuance that it 'validates' invariants and optionally verifies a pinned checkout, which goes beyond the annotations. However, it does not describe error behavior, edge cases, or report semantics, so it only partially enriches transparency.

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

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

The description is a single, well-structured sentence with two clauses. It front-loads the primary purpose and uses every word efficiently. There is no redundancy or filler, making it highly concise and readable.

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

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

The tool has an output schema and only two parameters, with annotations covering safety. The description gives a clear high-level purpose but lacks usage guidance and some parameter clarification. Given the presence of an output schema, the return values are already specified, so the description is adequate but not comprehensive for a conformance validation tool.

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

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

With 0% schema description coverage, the description must compensate for missing parameter explanations. The phrase 'optionally verify pinned checkout identity' gives a meaningful purpose for the optional upstream_path parameter. However, the required run_id is not directly explained, leaving a gap for a core parameter. The description adds some value but not complete 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 identifies the tool's primary action ('Validate portable observable invariants') and resource (conformance report), and it distinguishes itself from sibling tools by focusing on conformance/invariants rather than run management or dashboards. It is specific but does not explicitly contrast with alternatives, so it falls just short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention suitability conditions, exclusions, or alternative tools. The only contextual hint is the optional verification of pinned checkout identity, but there is no explicit usage direction.

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

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

Annotations already mark this as read-only, idempotent, and non-destructive. The description adds the 'presentation-safe' qualifier, implying the output is formatted or sanitized for display, which is extra context. However, it does not explain what 'safe' entails or any other operational caveats.

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

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

The description is one concise sentence that front-loads the primary action. Every word adds value, and it avoids unnecessary detail.

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

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

Given the tool's simplicity, output schema, and full annotations, the description is adequate but not rich. It lacks an explanation of what makes the summary 'presentation-safe' and does not position the tool among its siblings, so it falls short of complete contextual guidance.

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

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

The schema provides no description for run_id, and the description only says 'for a run,' which does not clarify the parameter's format or how to obtain it. With 0% schema description coverage, this is insufficient to fully understand the parameter.

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

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

The description clearly states the action ('Return') and the object ('presentation-safe dashboard summary for a run'), which is specific enough to distinguish from raw run data tools. However, it does not explicitly compare to sibling tools like get_run_view or get_run_result, so it misses the highest score.

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

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

There is no guidance on when to prefer this tool over the many run-related siblings. No prerequisites, alternatives, or exclusions are mentioned, leaving the agent to guess based on the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing the safe read-only nature. The description adds meaningful context by specifying that it returns implemented features, safety exclusions, and runtime readiness, which reinforces the informational purpose without contradicting annotations.

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

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

A single, front-loaded sentence with a clear verb and three concise items. Every word earns its place, with no repetition or filler.

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

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

For a zero-parameter, read-only tool with an output schema, the description is complete. It clearly communicates the tool's purpose, and the output schema handles detailed return structure, so no further explanation is needed.

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

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

The tool has zero parameters, so the schema provides full coverage. The description doesn't need to explain parameters, and the baseline for a parameterless tool is well-deserved.

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

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

The description uses the specific verb 'Return' with a clear resource: implemented features, safety exclusions, and runtime readiness. This clearly differentiates it from sibling tools like get_run or get_conformance_report by specifying the exact type of information returned.

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

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

The description implies this tool is used to assess what features are implemented, what safety exclusions exist, and whether the runtime is ready. However, it does not explicitly state when to prefer this over alternatives like discover_capability or get_conformance_report, nor does it mention any 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds context about the return style ('compact dashboard-oriented') but nothing further about auth, error behavior, or data scope. With annotations covering safety, this is adequate but not rich.

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

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

A single, concise sentence that front-loads the purpose. No unnecessary words or repetition. Efficient for agent consumption.

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

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

With an output schema present and strong annotations, the tool has enough structured context. The description is minimal but sufficient for a simple read-only getter. The 'dashboard-oriented' qualifier could be more precise, but overall completeness is acceptable.

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

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

Schema coverage is 0% and the description does not explain run_id. While the parameter name is fairly self-explanatory as an identifier, the description does not compensate for the lack of schema descriptions, leaving format or source of the ID ambiguous.

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

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

The description uses a specific verb 'Return' with a clear resource 'run record' and a distinguishing qualifier 'compact dashboard-oriented'. This separates it from sibling tools like get_run_events, get_run_result, and get_run_view, which imply different scopes or formats.

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. The phrase 'dashboard-oriented' hints at a use case, but the description doesn't specify exclusions or mention any sibling tools. Given the many similar get_* run tools, this lack of direction is a clear gap.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'Return' aligns with these. The description adds the concept of 'durable' state and specific data categories, but offers no additional behavioral context such as error handling or consistency guarantees. This is adequate given the annotations.

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

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

The description is a single action-first sentence that efficiently lists the returned information categories without any 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 simple one-parameter signature, output schema, and safety annotations, the description is mostly adequate. However, the lack of usage context differentiating it from the many sibling get_* tools is a meaningful gap, especially with a large sibling toolset.

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

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

The sole parameter run_id is self-explanatory from its name, but the description provides no additional meaning and schema description coverage is 0%. A brief mention of which run's control state is being queried would improve parameter understanding.

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

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

The description clearly states the tool's function: returning durable lifecycle status, revision, checkpoint, cancellation, and next stage. It uses a specific verb and resource list, which helps distinguish it from generic run retrieval tools, though it 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?

There is no guidance on when to use this tool versus sibling tools like get_run, get_run_events, or get_run_view. It only describes what it returns, leaving tool selection to inference.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds 'ordered' as a behavioral detail, but does not explain pagination, event types, or whether it returns the full history, which leaves gaps beyond what annotations provide.

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

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

The description is a single concise sentence that directly states the tool's function. It is front-loaded and contains no superfluous words, 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?

Given the tool's simplicity and the presence of an output schema, the description is minimal but lacks important context about how this compares to poll_run_events or whether the event stream is complete or limited. It is adequate for the basic action but leaves uncertainty about edge cases.

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

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

With 0% schema description coverage, the description was expected to compensate, but it does not describe run_id beyond what the schema already shows. The phrase 'for a run' hints at run_id's purpose, but offers no additional meaning like allowed formats or how to obtain a valid ID.

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

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

The description clearly states the action ('Return') and the resource ('ordered event stream for a run'). It is specific but does not explicitly distinguish from sibling tools like poll_run_events or get_run_result, so it earns a 4 rather than a 5.

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

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

The description gives no guidance on when to use this tool versus alternatives such as poll_run_events, get_run, or get_run_view. There are no usage contexts, exclusions, or alternative recommendations, so it provides minimal decision support.

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?

Annotations already disclose readOnly, idempotent, and non-destructive behavior. The description adds the detail that the result is 'full typed', which gives some insight into the return value, but it does not explain behavior around uncompleted runs, errors, or pagination. The description is consistent with annotations, so no contradiction.

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

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

The description is a single concise sentence that is front-loaded with the verb 'Return' and the resource. Every word earns its place, with no redundant information.

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

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

Given the tool's simplicity (one parameter, output schema present, strong annotations), the description is minimally viable. However, it lacks context about when to use this tool compared to siblings and does not mention potential error conditions or prerequisites. It provides the core purpose but leaves 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?

Schema description coverage is 0%, so the description must compensate. It only says 'for a run', which implies run_id is the run identifier, but it does not add meaning beyond the parameter title 'Run Id'. No format, constraints, or usage examples are provided for the single parameter.

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

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

The description clearly states the tool returns the full typed result for a run, using a specific verb and resource. It does not explicitly distinguish it from sibling tools like get_run or get_run_view, but 'full typed result' narrows the purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It merely states what the tool does, leaving the agent without context for selecting among the many sibling run-related 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=false, covering the safety profile. The description adds that the output is 'UI-ready' and a 'projection', indicating a transformed view rather than raw data. It does not disclose details like response format or potential errors, but given the output schema exists, this is acceptable.

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

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

The description is a single, focused sentence that is front-loaded with the main verb and resource. It is concise, avoids redundancy, and contains no unnecessary words or filler.

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

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

For a simple tool with one parameter, the description is largely complete: it states the purpose and the nature of the output ('UI-ready run projection'). The output schema and annotations fill in details about return structure and safety. However, it does not mention any prerequisites or caveats (e.g., whether the run must be in a certain state), which could be important for agent decision-making.

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

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

The schema has one parameter (run_id) with 0% description coverage, and the description does not mention run_id at all. The parameter name is self-explanatory, but the description provides no additional context or behavioral meaning beyond what the schema already states. Given the low schema coverage, the description should have compensated but did 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's function: 'Return the complete UI-ready run projection for inline harness rendering.' It specifies the verb (Return), the resource (run projection), and the purpose (inline harness rendering), distinguishing it from sibling tools like get_run or get_run_result, which likely return raw or processed data rather than a UI-ready projection.

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 ('for inline harness rendering'), providing some usage context. However, it does not explicitly mention alternatives or when not to use this tool versus similar get_run_* siblings. This is sufficient for an experienced user 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?

The description adds the behavioral detail that publishing is atomic, which is beyond the annotations (all false). It also implies validation occurs before publishing. However, it does not disclose error handling, permissions, or side effects beyond atomicity, and the annotations provide limited safety information.

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, front-loaded with the primary action. It contains no fluff or redundant information, scoring high on conciseness.

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

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

Despite the presence of an output schema, the description is too brief to provide sufficient context for a tool with a complex free-form payload. It lacks details about when to call it, how the payload should be constructed, and how it relates to sibling tools like commit_host_stage or finalize_host_run, making it inadequate for reliable invocation.

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

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

The input schema has a single payload object with no property descriptions, and the description does not specify what the payload should contain. With 0% schema coverage, the description fails to compensate, leaving the agent to guess the payload structure. The overall description hints at outputs and dossier, but this is insufficient.

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

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

The description clearly states the tool validates completed host stage outputs and atomically publishes the final dossier, specifying the action and resource. It is concise and conveys the core function, but it does not explicitly contrast with sibling tools like finalize_host_run or export_completed_run, so it lacks full differentiation.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or contextual steps. The phrase 'completed host stage outputs' implies it should be used after a stage is complete, but no exclusions or alternatives are mentioned.

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

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

The description only says 'Serve' and 'on loopback', which reveals little about side effects, whether the process blocks, how it terminates, or any resource cleanup. Annotations are all false, offering no safety or idempotency context, so the description carries the burden and falls short.

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 leads with the verb. Every word contributes meaning, and there is no redundancy or filler.

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

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

Given that this tool launches a local server, the description omits essential operational details such as whether it blocks, how to stop it, how port selection works, and what the output format is. With annotations providing no hints and the schema lacking descriptions, the description is inadequate for an agent to invoke it confidently.

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

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

Schema description coverage is 0%, and the description does not mention any of the parameters (host, port, run_id). It adds no meaning beyond the schema's bare names and types, so it fails to compensate for the lack of parameter documentation.

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

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

The description states a specific action ('Serve') and resource ('local dashboard assets and JSON APIs') with a clear network scope ('on loopback'). This unambiguously differentiates it from the run-management 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?

No guidance is provided about when to use this tool versus alternatives. The description is purely definitional and does not mention use cases, prerequisites, or exclusions.

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

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

The description adds a meaningful behavioral detail—pause is deferred to the next portable stage boundary—which is not captured by annotations (all false). However, it does not disclose whether the pause is resumable, what state the run enters, or any side effects, leaving significant ambiguity for a mutating operation.

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

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

The description is a single, front-loaded sentence with no redundant words. It immediately identifies the verb and object, and the 'portable stage boundary' qualifier adds essential nuance without bloat.

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 presence of many sibling lifecycle tools and a state-changing operation, the description is too sparse. It does not explain the concept of 'portable stage boundary,' the run state after pausing, or how this differs from cancellation/finalization. The output schema may cover return values, but the context for an agent to correctly select and invoke this tool 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 provides no explanation for any of the three parameters. 'expected_revision' (likely optimistic concurrency) and 'reason' (audit trail) are completely undocumented, so the agent has no semantic grounding beyond their names.

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

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

The description clearly states the action ('Pause') and the target ('a host run'), and adds a specific timing detail ('at its next portable stage boundary'). This distinguishes it from other lifecycle tools in the sibling list, though it 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 is provided on when to use this tool versus alternatives like request_run_cancellation or finalize_host_run. The phrase 'at its next portable stage boundary' implies a safe point, but there is no explicit mention of use cases or exclusions, leaving the agent to infer when this should be chosen.

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?

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds the concept of a 'monotonic cursor' and 'live' events, which implies a streaming or incremental read pattern that can be polled repeatedly. However, it does not disclose additional behavioral details such as how cursor progression works, what happens with invalid cursors, or pagination behavior. The added context is helpful but minimal.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and easy to parse. However, it is so brief that it sacrifices important context, making it slightly under-specified for a tool with multiple parameters and a polling use case.

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

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

Given the tool has 3 parameters, an output schema, and sits among many related tools, the description is too sparse. It does not explain return behavior, cursor mechanics, or how this relates to other event-reading tools. The output schema reduces the need to describe return values, but the description still lacks essential context for an AI agent to select and invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints at 'after a monotonic cursor' which relates to the after_sequence parameter, but does not explain run_id or limit. While parameter names are somewhat self-explanatory, the lack of any description of how they behave or interact in a polling context leaves gaps. The description adds marginal value beyond the raw schema.

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

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

The description clearly states the tool reads live lifecycle events using a monotonic cursor. It identifies the action (read), resource (live lifecycle events), and mechanism (after a monotonic cursor), making the purpose specific and understandable. However, it does not explicitly distinguish itself from the sibling tool 'get_run_events', which likely has similar functionality, so it falls short of a perfect clarity score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or scenarios where this tool is preferred over other event-related tools like get_run_events. The usage context must be inferred from the name and cursor mention, which is insufficient.

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?

Annotations already declare readOnlyHint=true and idempotentHint=true, but the description adds meaningful behavioral context by stating the tool does not execute the fixture. The 'validate and expand' actions are described, and no contradiction with annotations exists.

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

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

A single sentence of twelve words, front-loaded with the action and resource. Every word earns its place, with the key qualifier 'without running it' immediately disambiguating from run_fixture.

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

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

For a tool with four optional parameters and an output schema, the description covers purpose and the key non-execution trait, but omits any parameter guidance. It is complete enough as a high-level preparation step, but lacks sufficient detail to fully configure the tool without external knowledge.

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 0% parameter description coverage, yet the description does not explain what analysts, as_of_date, risk_rounds, or debate_rounds mean or how they influence validation/expansion. It provides no semantic value beyond the schema's parameter names and defaults.

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

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

The description uses specific verbs 'Validate and expand' to identify the action, names the resource 'deterministic ORCL fixture', and also distinguishes it from running the fixture via 'without running it'. This clearly differentiates it from sibling tools like run_fixture.

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

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

The phrase 'without running it' clearly indicates this is a pre-run preparation step, providing context on when to use it relative to run_fixture. However, it does not explicitly list when not to use it or mention alternatives, so it stops slightly short of full 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds a behavioral nuance: it returns a 'canonical plan' and requires no model credentials, but it does not disclose what the plan contains or any effects on the host harness. The added value is modest given the annotations.

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

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

The description is a single, concise sentence that front-loads the purpose and a key constraint ('accepts no model credentials'). Every word contributes, with no redundant or promotional language, 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?

Despite having an output schema that can explain return values, the description is too sparse for a tool with 7 parameters and many siblings. It fails to explain what the canonical plan is, how parameters affect it, or how this tool relates to other preparation or execution tools. The agent would struggle to invoke it correctly.

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

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

The schema has 0% description coverage for its 7 parameters, and the description does not mention any of them (symbol, analysts, as_of_date, etc.). The single note about 'no model credentials' does not clarify the parameters or their purpose, leaving the agent without any semantic guidance for 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 uses a specific verb ('Return') and a resource ('canonical plan for the active host harness'), making the core purpose clear. It also notes 'accepts no model credentials,' which hints at its role in preparation. However, it doesn't explicitly distinguish from sibling tools like 'create_host_run' or 'prepare_fixture'.

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 by indicating the tool operates on the 'active host harness' and requires no model credentials, suggesting it is a preparation step rather than a runtime action. However, it does not explicitly state when to use this tool over alternatives or when not to use it, missing the opportunity to name exclusion 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it is a safe read. The description adds useful behavioral specifics about the recall limits (same-symbol and cross-symbol counts), but does not detail return format or pagination; since an output schema exists, this is adequate.

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

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

The description is a single, front-loaded sentence that conveys the core action and constraints. Every word earns its place; no filler or redundancy.

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

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

With read-only annotations and an output schema present, the description covers the essential behavior. The limits are specified, and the tool is simple enough that this is nearly complete. Slight ambiguity around the meaning of 'cross-symbol' could be clarified, but overall it is sufficient for a read-only query tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly mentions 'same-symbol' and 'cross-symbol' which map to same_symbol_limit and cross_symbol_limit, and 'symbol' is implicit from the tool name. This adds meaning, but the description does not explicitly define the symbol parameter or explain how limits interact.

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

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

The description uses the specific verb 'Recall' with the resource 'prior decisions' and provides concrete limits ('up to five same-symbol and three cross-symbol'). This clearly distinguishes it from run-centric siblings like get_run or poll_run_events by focusing on decision memory.

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

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

The description implies this tool is for recalling prior decisions (the verb 'Recall' suggests a read-only query), but it does not explicitly state when to use it versus alternatives or provide any exclusions. The presence of record_decision_outcome as a sibling implies the read counterpart, but no explicit guidance is given.

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's 'append' implies a mutating operation, consistent with readOnlyHint=false. Annotations already indicate it is not read-only, idempotent, or destructive. The description adds the notion of appending to an existing decision but does not disclose side effects like whether repeated appends create multiple outcomes or require certain IDs to exist. This meets the lower bar set by annotations but does not provide rich 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 is a single, front-loaded sentence with no filler. Every word contributes to the core meaning, making it highly concise and appropriately structured.

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

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

For a tool with 5 parameters, 0% schema descriptions, and limited annotation value, the description is insufficient. It does not explain the relationship between run_id/memory_id and the 'prior research decision,' nor the expected format of outcome/reflection. Although an output schema exists, the input semantics are critically under-specified for an agent to invoke this correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'outcome and reflection,' which maps to the two required parameters, but gives no detail about them or the optional run_id, memory_id, and observed_at. The purpose of these parameters (e.g., how they identify the prior decision or timestamp the outcome) is entirely unexplained.

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

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

The description uses the specific verb 'append' with a clear resource ('prior research decision') and object ('host-observed outcome and reflection'). It distinguishes itself from sibling tools like append_run_receipts by targeting decision outcomes rather than run receipts, and from query_decision_memory by focusing on writing rather than reading.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites (e.g., that a prior decision must exist) or exclusions (e.g., when to use append_run_receipts instead). The description only states what it does, not when to invoke 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?

Annotations indicate a non-read-only, non-destructive mutation, but the description adds the key behavioral trait that cancellation is cooperative and the host owns interruption. This explains the interaction model beyond what annotations convey.

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 short, front-loaded sentences. Every word earns its place, communicating the core action and a key behavioral constraint without any 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?

The description is adequate for a basic understanding but lacks context about prerequisites (e.g., needing a run_id and expected_revision), relationship to acknowledge_run_cancellation, and what success or failure looks like. An output schema exists, which helps, but gaps remain.

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

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

Schema description coverage is 0%, and the description provides no information about run_id, expected_revision, or reason. expected_revision in particular is non-obvious and goes unexplained, failing to compensate for the lack of schema docs.

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 requests cancellation of a run, with 'cooperative' adding a specific scope. It distinguishes from siblings like acknowledge_run_cancellation by implying a request instead of an acknowledgment, though it could be more explicit about the flow.

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

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

No guidance is given on when to use this tool versus alternatives such as pause_host_run or acknowledge_run_cancellation. The description implies cooperative cancellation is different, but does not state conditions 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?

Annotations are all false, so they provide no safety profile. The description adds the behavioral detail that it resumes and replays interrupted work, but it does not disclose side effects, prerequisites, or how run state changes beyond that, leaving gaps.

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

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

The description is short, front-loaded with 'Resume,' and contains no filler. The two clauses are slightly redundant, but overall it is appropriately concise 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?

Despite having an output schema, the required expected_revision parameter is left unexplained, and 'portable stage' is not clarified. The description does not provide enough context about how this resume operation relates to siblings like start_host_run or commit_host_stage.

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

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

Schema description coverage is 0%, and the description does not mention run_id or expected_revision at all. The purpose of expected_revision is entirely unexplained, so the description fails to compensate for the low schema coverage.

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

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

The description uses the specific verb 'Resume' with a clear resource ('first incomplete portable stage') and adds 'replay interrupted work,' making its purpose distinct from sibling tools like start_host_run and pause_host_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 clearly implies when to use it—after an interruption, to resume unfinished work—but it does not explicitly name alternatives or exclusion cases, so it falls short of a 5.

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

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

Annotations are present but all set to false, offering no safety hints. The description adds 'deterministically' and 'in-memory', which are useful behavioral traits (reproducibility, non-persistence), but it does not disclose prerequisites, side effects, or lifecycle implications. Since annotations exist, the bar is lower, and some credit is given for this added context.

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

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

The description is a single sentence that conveys the core function and two key distinguishing traits (deterministic, in-memory). It is front-loaded and contains no filler, making it appropriately concise for a straightforward run 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?

Despite the presence of an output schema (which covers return values), the description lacks context about the run lifecycle, whether a prepared fixture is required, how parameters influence stages, and how this differs from host-run siblings. For a tool with four parameters and no schema descriptions, 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%, so the description must compensate for the lack of parameter documentation. It does not mention any of the four parameters (analysts, as_of_date, risk_rounds, debate_rounds) or explain how they affect the run. The only indirect hint is that 'all stages' implies rounds/controls, which is insufficient.

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

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

The description clearly states the tool runs all stages deterministically and stores the in-memory result and events. It identifies the resource ('all stages' of the fixture) and the action, and the 'deterministically' and 'in-memory' qualifiers help distinguish it from sibling run tools, though it doesn't explicitly name the fixture or contrasts.

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

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

No guidance is provided on when to use this tool versus alternatives like start_host_run or prepare_fixture. The description only states what it does; there are no explicit use cases, exclusions, or references to sibling tools, leaving the agent without decision-making 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?

The description adds context beyond the annotations by noting the run must be 'durable' and 'prepared', and that the tool returns the first stage, implying a multi-stage or asynchronous process. It does not contradict annotations and enriches understanding of 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, front-loaded sentence that conveys the essential information without any redundant words or clutter.

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

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

The description covers the core action but leaves significant gaps: parameter semantics (especially 'expected_revision'), prerequisites, and usage context relative to sibling tools. The output schema exists, so return details are not needed, but other context is still missing.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention 'run_id' or 'expected_revision' at all. 'expected_revision' is particularly ambiguous (likely an optimistic locking check) and goes 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 ('Start'), the resource ('host run'), and the return value ('its first stage'). It also distinguishes from siblings by emphasizing 'prepared', which indicates this tool is for starting an already-prepared run, not creating or preparing one.

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

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

The description implies a prerequisite ('prepared') but does not explicitly state when to use this tool versus alternatives like 'prepare_host_run' or 'create_host_run'. No exclusions or named alternatives are provided, so guidance is only implicit.

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