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

With no annotations, the description carries the full behavioral burden, but it only names report content. It does not state whether the tool is read-only, whether it requires a session, what response shape to expect, or what the required `name` refers to. The phrase 'list-price estimate' hints at a non-authoritative estimate, but that is minimal.

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

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

The description is compact and front-loads the domain ('journaled model calls') with no filler. However, it is a fragment and omits necessary context, so its brevity is more under-specification than effective conciseness.

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

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

For a tool with one required parameter and no output schema, the description omits the meaning of `name` and any usage context. It names the source and two metrics, but an agent cannot reliably determine how to invoke the tool or what to expect in return.

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 never mentions the required `name` parameter. The agent is left to guess whether `name` is a session name, a report name, or a model-call identifier.

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

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

The description identifies the resource ('cost report from the journaled model calls') and the report contents ('list-price estimate, cache hit rate'), so an agent can infer what the tool does. However, it is a noun phrase rather than a verb-headed action sentence, and it does not explicitly distinguish this tool from sibling `export_report`.

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 data source ('journaled model calls') but no when-to-use guidance. It never mentions alternatives such as `query_journal` or `export_report`, nor does it state any 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?

With no annotations provided, the description carries the transparency burden. It discloses that input paths are resolved server-side and restricted to authorized roots, which is a useful behavioral constraint. However, it does not mention side effects like whether a session ID is returned or if persistent state is created.

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

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

The description is two concise sentences, front-loading the primary purpose and then adding key constraints. There is no redundant or extraneous content, 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 has 10 parameters including a nested brief object, the description is undercomplete. It explains the brief's required fields and path restrictions, but omits details about other parameters, expected output, and potential errors, leaving significant gaps for an agent to navigate.

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 description coverage, so the description must compensate. It explains that the brief requires problem_space, target_segments, success_criteria, and risk_tolerance, and may include input paths. However, it leaves many other parameters (mode, provider, panel_size, gate_policy, reasoning_effort, total_token_budget) without semantic explanation, requiring the agent to rely on names and enums.

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 creates a Design Thinking session, which is a specific verb and resource. However, it does not explicitly distinguish it from sibling tools like run_session or step_session, so it falls slightly short of a perfect 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 compared to alternatives such as run_session or step_session. There is no indication of the appropriate context or conditions for invoking this tool.

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

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

With no annotations, the description carries the behavioral burden. It states the operation (export), the exact artifacts produced (PPTX and HTML), and the return value (paths), but it does not disclose whether the export overwrites files, where paths point, whether a run must be complete, or any permission requirements.

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 conveys the action, the output formats, and the returned data with no filler. The essential information is front-loaded.

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

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

For a one-parameter tool, the description covers the core action and return, but it omits the parameter meaning and any usage context. It is adequate for a minimal invocation yet leaves an agent guessing about prerequisites and what 'name' should contain.

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 only parameter, `name`, has no description in the schema. The description references a 'run report' but never explicitly states whether `name` is the run's name, a report name, or an output filename, leaving the parameter 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 names a concrete action and resource ('Export the run report') and specifies the two output formats (PPTX deck + self-contained HTML). It does not explicitly contrast with the 13 sibling tools, so it falls short of full sibling 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?

No guidance is given about when to call export_report versus siblings such as run_session, get_status, cost_report, or generate_handoff. The agent must infer that a run report exists before exporting; there are no 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?

With no annotations, the description carries the full burden, but it only reveals that a dossier is generated and paths are returned. It does not disclose side effects, whether it mutates session state, idempotency, required permissions, or what 'export paths' refer to.

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 short sentence that leads with the action and immediately states the return value. There is no filler or redundant restatement of structured fields.

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

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

For a simple one-parameter tool this might be close, but with no output schema, no annotations, and no naming context for the parameter, the description leaves too much for the agent to infer: what a Session Dossier is, what the name refers to, and what happens to the session.

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

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

The lone parameter 'name' is listed in the schema but the description adds no meaning to it; there is 0% schema coverage. It is not clear whether 'name' is the dossier name, session name, or export prefix, making the parameter under-specified.

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

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

The description names a concrete action ('Generate'), a specific resource ('the Session Dossier'), and the expected result ('return the export paths'). It does not, however, explicitly differentiate this from the sibling generate_handoff, which an agent might confuse it with.

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

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

There is no guidance about when to call generate_dossier versus run_session, generate_handoff, or other siblings. The description gives no context, prerequisites, or exclusions, so an agent must infer usage from the tool name.

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

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

With no annotations, the description must disclose behavior itself. It does reveal a conditional refusal and the output's intended ingestion format, but it does not say whether the tool returns the spec, writes files, or errors on refusal, so an agent is left guessing about side effects and response shape.

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 dense sentence contains the purpose, output consumer, and refusal behavior without filler. The parenthetical is compact, though the sentence could be split for easier scanning.

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 one-parameter tool with no annotations or output schema, the description covers the core contract but leaves the parameter mapping implicit and does not describe what a successful/refused call returns. Sibling differentiation is present through the artifact type but not named.

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

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

The only parameter, 'name', has no schema description, and the description only indirectly ties it to 'the validated concept'. This gives a reasonable inference that name identifies the concept, but it does not explicitly define the expected value format or scope.

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 ('Generate') and a specific resource ('OpenSpec MVP specifications'), and adds a concrete consumer ('coding harness') plus an exclusion condition ('refused for killed concepts'). This is enough to distinguish it from siblings like generate_dossier, which produces a dossier rather than handoff specs.

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

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

It clearly states the tool applies to 'validated concept' work and will refuse 'killed concepts', giving an explicit when-to-use and when-not-to-use. It does not name an alternative tool for killed concepts, but it still provides actionable selection context.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only observation ('where the session is') and adds that the tool surfaces blocking issues. But it doesn't explicitly state side-effect freedom, required permissions, or behavior when the named session doesn't exist.

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

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

The description is short, front-loaded, and avoids filler. It could be slightly more complete as a full sentence with an explicit verb, but as written it is economical and not bloated.

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

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

With no output schema, no annotations, a single undocumented required parameter, and only a ten-word description, the agent has too little to reliably invoke the tool. The description conveys the concept of status/blockers but not the calling contract. The sibling list provides surrounding context, but the description itself remains 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?

The schema has one required parameter, 'name', with no description and 0% schema deck cover. The tool description never directly explains what 'name' should be, though the word 'session' implies it is a session identifier. Valid sources for the name and format are left unstated.

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 what get_status reports: the session's current position and what blockers are present. It is clear enough to distinguish from action-oriented siblings like run_session and step_session. However, it doesn't differentiate from list_sessions_tool, which may also surface session state.

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

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

The description provides no explicit guidance on when to call this tool versus list_sessions_tool, resolve_gate, or step_session. There are no stated prerequisites, such as the session needing to exist or be running. Usage is left entirely 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?

With no annotations, the description carries the full disclosure burden. It communicates a read-only listing action, but does not disclose return format, pagination, session-state filtering, or whether it covers all sessions in the workspace. This is minimally adequate for a simple list operation but thin.

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

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

The description is a single concise sentence with no filler. The scope modifier 'in the workspace' adds useful context and is front-loaded effectively.

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 listing operation, the description is nearly complete. The lack of an output schema and any mention of returned session fields or defaults leaves a minor gap, and the existence of get_status creates mild ambiguity about which tool answers which session-related need.

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

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

The tool has zero parameters, so the baseline of 4 applies. There is no parameter information to add beyond what the empty input schema already shows, and the description does not need to compensate.

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

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

The description states a clear verb and resource ('List sessions') and adds a workspace scope. The verb 'list' distinguishes it from action-oriented siblings like run_session, create_session_tool, step_session, and stop_session, though it does not explicitly point to any 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 get_status or the other session-related siblings. There are no exclusions, conditions, or alternative suggestions, leaving the agent to rely on naming 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It does communicate that the operation is a read and that output follows a 'canonical form', which is useful. However, it does not explain pagination, ordering, error behavior, filtering semantics, or whether since_seq/limit behave as expected. The CLI reference is opaque without additional 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 phrase—'Read', 'ledger events', 'same filters', 'canonical form'—contributes meaning. This is appropriately terse for the dimension, though the terseness hurts completeness elsewhere.

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 six parameters, an output schema, and no annotations, yet the description provides almost no parameter semantics, no usage context, and no behavioral detail beyond 'read' and 'CLI-compatible'. An agent would struggle to know what 'name' refers to or how filters are combined. The presence of an output schema does not compensate for these gaps.

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

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

Schema description coverage is 0%, so the description must compensate for six undocumented parameters. It only says 'same filters' but does not define what filter values are expected for name, type, actor, stage, limit, or since_seq. The reference to the CLI hints at semantics but does not give the agent enough information to construct a correct call.

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

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

The description states a clear verb+resource: 'Read ledger events'. It distinguishes this from sibling session-control tools like run_session or get_status by focusing on ledger events rather than session lifecycle. However, it does not explicitly explain what a 'ledger event' is or how this differs from list_sessions_tool, 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 phrase 'with the same filters and canonical form as the CLI' implies a familiar command-line workflow and suggests this tool is the read/query counterpart to session actions. But there is no explicit when-to-use guidance, no exclusions, and no mention of when a sibling like get_status would be a better fit. Usage is implied rather than articulated.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the backward move and allowed stage pairs, without explaining side effects on the current session, whether prior work is preserved, or how the loopback request is resolved.

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

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

The description is a single compact sentence with the action front-loaded and a dense transition list. It is concise and free of filler, though it is terse enough that it under-serves the required parameters.

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 state-changing tool with no annotations and no output schema, this description is incomplete. It identifies allowed transitions but leaves required parameters unexplained, effects unspecified, and sibling-tool relationships unaddressed.

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

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

Schema description coverage is 0%, and the description only mildly hints at valid values for to_stage through the examples. It provides no meaning for the required name and reason parameters, leaving an agent unable to construct a correct call confidently.

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

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

States a specific action ('Loop back to an earlier stage') and enumerates allowed transitions (test->define, test->empathize, define->empathize), which clarifies what the tool does. It does not explicitly distinguish itself from siblings like step_session or resolve_gate, so it stops short of 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?

No guidance is given on when to use this tool versus siblings such as step_session or submit_input. The transition list implies it is for backward movement, but there are no exclusions, triggers, or alternative-routing instructions.

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

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

With no annotations, the description carries the behavioral burden. It discloses that rejecting requires a reason, which is a useful non-schema constraint, and the approve/reject wording makes it clear this changes state. However, it does not describe side effects, irreversibility, or what happens to the session after resolution.

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: the action, the target, and the critical rejection-reason rule.

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

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

Given the absence of annotations and output schema, the description is too thin. It leaves the meaning of the required 'name' parameter ambiguous and does not explain what happens after the gate is resolved, which an agent would need to safely invoke the tool in a session workflow.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that rejection requires a reason, but it does not explain what 'name' refers to or how it should be supplied. 'resolution' is understandable from the enum, yet two of the three parameters remain under-specified.

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

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

The description clearly states the action ('Approve or reject') and the resource ('the pending gate'), and the resolution enum makes the two possible outcomes explicit. It is distinguishable from the sibling tools, none of which mention gates, though the term 'gate' is left somewhat domain-specific.

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?

Use when a gate is pending is implied by 'the pending gate', but the description does not explicitly explain when this tool should be chosen over alternatives or when it should not be used. There is no mention of prerequisites or workflow position.

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 disclosure burden and does add meaningful behavior: the session advances until a halt type and completed runs are finalized automatically in a specific order. It does not mention errors, asynchrony, or state-mutation side effects, but the core behavioral contract is present.

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

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

Two sentences, front-loaded with the main action and outcome, with no filler. The halt list and finalization sequence are compact but high-value details.

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

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

With no annotations and no output schema, the description must explain parameter meaning, return behavior, and halt handling, but it explains none of those. The finalization note is useful, yet an agent still lacks enough to know what to expect after an 'input' halt or what the call returns.

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 a single 'name' property with only a title, and schema description coverage is 0%. The description never mentions 'name' or what it identifies, so the agent receives no semantic help for the only 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 states a specific action ('Advance') and resource ('the session') and defines the target outcome via halt types. It conveys the tool's role among sibling session tools, though it does not explicitly distinguish it from step_session.

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

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

No guidance is given about when to choose run_session versus step_session, stop_session, resolve_gate, or submit_input. The behavior is described, but there are no conditions, exclusions, or alternative routing cues.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal the 'at most one stage' constraint, but it does not mention side effects, failure behavior, reversibility, or whether the operation is idempotent. For a state-mutating action, this is a significant transparency gap.

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

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

The description is a single, focused sentence with no filler. The core verb and constraint are front-loaded, and every word earns its place.

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

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

Given one undocumented required parameter, no output schema, no annotations, and a large sibling toolset, the description is too thin. It lacks the meaning of 'name' and says nothing about return values or errors, making it difficult for an agent to call correctly in all situations.

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 meaning of the required 'name' parameter. The agent must guess that 'name' identifies the session, which is not explicitly stated anywhere. The description adds no value over the raw schema 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 uses a specific verb ('advance'), identifies the resource ('session'), and adds a precise qualifier ('by at most one stage') that distinguishes it from siblings like run_session or resolve_gate. An agent can confidently tell what action this tool performs and how it differs from related operations.

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

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

The description implies when to use the tool (whenever a session should progress by one stage), but it does not explicitly state when to choose it over alternatives such as run_session or submit_input, nor does it mention any exclusions or prerequisites. The usage context is left 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?

With no annotations, the description carries the burden and does a good job: it discloses that the stop is journaled, human-initiated, and non-destructive since the session stays resumable. It omits possible error states or idempotency, but the core behavioral profile is transparent.

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

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

One dense sentence with no filler. Key qualifiers ('journaled', 'human-initiated', 'stays resumable') are packed in without redundancy, and the core action is front-loaded.

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

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

For a two-parameter stop operation, the key behavioral promise is present, but there is no output or error information and no parameter clarification. It is minimally adequate but leaves room for the agent to guess details about name resolution and return values.

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

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

Schema description coverage is 0%, so the description should compensate, but it does not explain 'name' or 'reason' beyond their schema titles. An agent must infer that 'name' identifies the session and 'reason' is an optional journaled explanation.

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

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

States the specific action ('Stop the run'), identifies the target resource ('session'), and adds precise scoping: journaled, human-initiated, and resumable. This clearly distinguishes it from siblings like run_session and step_session.

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 clear context: use for a deliberate human-initiated stop where the session must remain resumable. It does not explicitly name alternatives or when-not conditions, but the intended usage is inferable and distinct from run/step semantics.

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 attribution and journaling of simulated evidence, but with no annotations it doesn't mention other side effects or state changes that may occur.

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

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

Two sentences with no excessive detail; the 'then run_session again' instruction is slightly extraneous but not bloated.

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?

Leaves parameter semantics and output/result behavior unexplained; only partial workflow context is given.

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 no parameter descriptions and the tool description only hints at 'question'; 'name', 'question_id', and 'answer' are not explicitly defined.

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

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

Clearly states the tool answers a pending Founder-mode session question and references run_session for the next step; however, it doesn't explicitly distinguish from sibling tools beyond that.

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?

Indicates when to use (pending question) and the next step (run_session again), but doesn't spell out when not to use or how it compares to alternatives like run_session or step_session.

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