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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds value by specifying a prerequisite (active project) and a finer-grained guarantee ('cannot rewrite semantic state') that goes beyond the annotations. No contradiction 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?

The description is a single, front-loaded sentence beginning with 'Read-only,' followed by the action and constraints. It is concise, though 'Read-only' and 'cannot rewrite semantic state' are slightly redundant, preventing a perfect score.

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

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

For a no-parameter read-only tool with an output schema and strong annotations, the description provides the key prerequisite (active project) and a meaningful behavioral constraint. It does not explain what 'Context Handoff content' or 'engine compiler' mean, but the output schema and simple invocation surface keep this gap minor.

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 and 100% schema description coverage, so there is nothing for the description to explain about arguments. The baseline for zero-parameter tools is 4, and the description does not introduce any parameter-related confusion.

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

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

The description states a specific action (compile), a specific resource (Context Handoff content), and a mechanism (engine compiler). It also signals read-only behavior. However, it does not explicitly differentiate itself from the sibling tool compile_living_document, though the resource name provides some implicit distinction.

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 compiling Context Handoff content and explicitly notes that an active project is required. It does not name alternatives or provide when-not-to-use guidance, so an agent must infer when this tool is preferred over similar siblings like compile_living_document or preview_round.

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 value beyond those by stating 'Read-only', specifying the engine renderer, requiring an active project, and explicitly noting it 'cannot rewrite semantic state' — useful behavioral context not present in 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 two short sentences with no filler. The read-only caveat is front-loaded, followed by the action, prerequisite, and a safety constraint — every element earns its place.

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

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

With no parameters, an existing output schema, and annotations already covering read-only, idempotent, and destructive behavior, the description supplies the remaining necessary context: the active-project requirement and the semantic-state guarantee. Nothing critical is 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?

The tool has zero parameters, so there is nothing for the description to document beyond what the empty schema already shows. The 0-parameter baseline of 4 applies here because no parameter guidance is needed.

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

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

The description states a specific verb ('Compile'), a specific resource ('Living Application Document'), and a mechanism ('engine renderer'), and opens with 'Read-only' to clarify scope. This clearly distinguishes it from siblings like compile_context_handoff and preview_round without needing to inspect schemas.

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 clear prerequisite ('Requires an active project') and indicates the operation is read-only, which gives useful context. However, it does not explicitly mention when to prefer this tool over alternatives such as compile_context_handoff or preview_round, nor does it state when not to use it.

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

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

Annotations already indicate readOnlyHint=false, so the description's 'Mutating session operation' is consistent. It adds value by explicitly stating what the operation does NOT do: 'It does not mark the project complete or commit a draft.' This clarifies side effects beyond the annotation metadata.

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

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

The description is concise and front-loaded with its mutating nature, followed by a concrete action and clarifying non-effects. 'Safely through the engine' is slightly vague but does not undermine clarity.

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

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

For a zero-parameter mutating operation with output schema and annotations provided, the description is largely complete. It explains the core action and important non-effects. It does not mention whether the session can be resumed later, but this is not essential for basic 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 tool has zero parameters and the schema coverage is effectively 100%, so there is no parameter documentation burden. The description appropriately focuses on behavior rather than inputs.

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

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

The description clearly states the operation: 'End the active Design Flow session safely through the engine.' It identifies a specific verb and resource, and clarifies it is a mutating session operation. It does not explicitly distinguish itself from sibling tools, but the purpose is unmistakable.

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

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

The description implies use when ending an active Design Flow session, but it gives no explicit guidance on when to use this tool versus alternatives like resume_project, new_project, or lock_round. There is no scenario-based direction or exclusion criteria.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds 'concise' regarding response nature and mentions no mutation capability, but the latter is redundant with the annotations and adds limited additional 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 brief and front-loaded with the read-only nature and the core action. The phrase 'It exposes no mutation capability' is somewhat redundant with 'Read-only', which slightly reduces efficiency, but overall the description is well-sized.

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 largely sufficient. It identifies the key result categories (current, affected, historical) and safety profile. It could be more complete by stating when to prefer this over sibling read tools, but the simplicity of the tool lowers that burden.

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?

There are no parameters, and schema description coverage is 100% (empty schema), so the description carries no obligation to explain parameters. The baseline of 4 applies here since the tool has no parameters to document.

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 concise current, affected, and historical engine concepts, which is a specific verb and resource. It does not explicitly differentiate itself from siblings like get_state or get_round, so it falls 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 gives no guidance on when to use this tool versus alternatives such as get_state, get_round, or get_unresolved. It only states what the tool does, not the conditions or context that should lead an agent to choose 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 already provide readOnlyHint, idempotentHint, and destructiveHint, so the description's read-only and no-mutation statements add little new safety information. The added 'concise view' wording gives a mild output-behavior hint, but no deeper context such as permissions, data scope, or freshness.

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 brief and front-loaded with the read-only nature and the return object. The phrase 'It exposes no mutation capability' is somewhat redundant with 'Read-only', but the overall structure is clean and efficient.

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

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

For a zero-argument read-only tool with a known output schema and strong annotations, the description is nearly complete. The main missing piece is how this tool relates to sibling read-oriented tools, which is already reflected in the usage_guidelines score.

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 there is no parameter semantics for the description to clarify. Baseline 4 applies for a no-parameter 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 states a specific verb ('Return'), a resource ('engine decision-ledger view'), and an output quality ('concise'). It is clear about what the tool does, though it does not differentiate itself from sibling getters like get_trace or get_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 only notes that the tool is read-only and has no mutation capability. It gives no guidance about when to use this tool versus sibling tools such as get_state, get_trace, or get_round. An agent must infer the usage context from the tool 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, idempotentHint, and destructiveHint. The description adds the useful prerequisite that an active project must exist, and clarifies the two distinct records returned (draft summary and committed round). No contradiction with 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 two short sentences with no filler. 'Read-only' is front-loaded, and every clause contributes either to scope, prerequisites, or non-mutating behavior.

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

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

For a parameterless tool with an output schema and strong annotations, the description is complete. It specifies the prerequisite, the exact data returned, and the fact that no editing occurs. An agent has everything it needs to invoke the tool correctly.

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

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

There are zero parameters, so there is no parameter-semantic burden on the description. The schema has no properties, and the description adds no parameter details, but none are needed. A baseline of 4 is appropriate for a parameterless 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 states a specific verb ('Return') and a specific resource ('active draft summary and latest committed round'). It clearly distinguishes itself as a read-only retrieval tool from siblings like lock_round, and the 'cannot edit' statement reinforces its non-mutating 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?

It clearly states the prerequisite context: 'Requires an active project.' It does not explicitly name alternative tools or when-not-to-use conditions, but the read-only framing and the specific return values make its appropriate context reasonably clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description's 'Read-only' adds no new safety information. However, it does add useful behavioral context about what the session brief contains and the distinction between MCP connection and Design Flow session, which is beyond the structured 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?

Two short sentences with no filler. The read-only nature is front-loaded, the return content is stated, and the clarifying exclusion is concise and meaningful.

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, read-only, idempotent tool with an output schema and complete annotations, the description covers all necessary context. The only additional nuance it might include is naming sibling alternatives, but the clarity of the purpose makes that unnecessary for correct invocation.

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

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

The tool has zero parameters, so parameter semantics are trivially satisfied. The description correctly focuses on return semantics rather than inputs, which is appropriate for a parameterless 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 states a specific verb ('Return') and resource ('engine session brief and semantic session identity'), and explicitly distinguishes itself from conflating the MCP connection with the Design Flow session. This makes its scope clear even among many sibling tools.

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

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

The description conveys when this tool is appropriate: when the agent needs the session brief and semantic session identity. It also provides a negative constraint by clarifying that MCP connection details are not the same as the Design Flow session, though it does not explicitly name sibling 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 establish read-only and non-destructive behavior. The description adds meaningful context by specifying that the state is 'compiled by Design Flow,' is concise, requires an active project, and cannot alter decisions, TRACE, or persistence. No contradiction with 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 front-loaded sentence with no filler. It states read-only nature, the resource, the main precondition, and a safety guarantee without redundancy.

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

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

With zero parameters and an output schema present, the description only needed to cover usage context and behavioral constraints, which it does. The active-project prerequisite and non-mutating guarantee complete the picture for safe 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 tool has zero parameters and schema coverage is complete, so there are no parameter semantics the description needs to clarify. The baseline of 4 is appropriate for a zero-parameter 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 identifies a clear verb and resource: 'Return concise state compiled by Design Flow.' It distinguishes this from generic mutators and implies an aggregate view, but it does not explicitly contrast with sibling getters like get_session_brief or get_trace.

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

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

It provides a clear precondition ('Requires an active project') and implies use when a concise, read-only overall state is needed. However, it does not name alternative tools for related needs or give when-not-to-use guidance, leaving sibling selection somewhat 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context beyond that: TRACE records are engine-owned and no tool can modify them directly, clarifying the immutability boundary.

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 sentences with no redundant wording. The read-only nature is front-loaded, and the immutability statement earns its place by adding meaningful constraint information.

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

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

For a zero-parameter read-only tool with an output schema and relevant annotations, this description is complete enough. The main potential gap is defining 'TRACE', but the resource name and context make it sufficiently identifiable.

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?

There are zero parameters, and schema description coverage is 100%. No parameter documentation is needed in the description, so the baseline of 4 is appropriate.

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

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

The description clearly states the action ('Return') and the specific resource ('engine-owned TRACE records'). It also distinguishes this tool from sibling get_* tools by naming TRACE records as the unique target.

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

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

The description does not explain when to prefer get_trace over sibling tools like get_state, get_unresolved, or get_round. It only notes that no tool can append/edit/delete TRACE directly, which is a limitation but not a clear usage scenario or alternative-selection rule.

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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: it states the tool requires an active project, returns the canonical register, and explicitly does not reconstruct or change authority.

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 sentences with no filler. The key facts are front-loaded ('Read-only. Return...') and the additional constraints ('Requires an active project', 'does not reconstruct or change authority') each add distinct value.

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

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

For a parameterless, read-only tool with a provided output schema and strong annotations, the description is complete. It covers the essential precondition, the exact resource returned, and the critical negative behavior (does not change authority).

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 is trivially complete with 100% coverage. The description does not need to add parameter-level meaning, and the baseline of 4 applies for parameterless tools.

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

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

The description states a specific verb ('Return') and a specific resource ('the engine's canonical unresolved register'), making the tool's purpose immediately clear. This also distinguishes it from sibling tools like get_state or get_round, which target different resources.

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

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

The description explicitly states a precondition ('Requires an active project'), giving the agent context on when it can be invoked. It does not explicitly name sibling alternatives or exclusion conditions, but the 'canonical' phrasing and 'does not reconstruct' contrast imply when this tool is appropriate.

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

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

The annotations already mark it as mutating and non-destructive. The description adds useful context beyond that: it operates on working state, imports exactly one item, and does not commit a decision or change semantic authority. No contradiction with 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?

Two dense sentences with no filler. The key behavioral scope is front-loaded, and every sentence adds meaningful context.

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

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

Given only two optional parameters, existing output schema, and annotations, the description covers the main semantics and exclusions well. The unexplained 'allowed-root' concept and exact input validation behavior are minor 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?

With 0% schema description coverage, the description compensates by mapping 'structured object' to the draft parameter and 'allowed-root file' to the draft_file_path parameter, also imposing an 'exactly one' constraint. It does not explain allowed-root rules or behavior when both parameters are used.

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 precise verb and resource: 'Import exactly one structured object or allowed-root file through engine draft intake.' This clearly distinguishes it from sibling tools that read, lock, compile, or end sessions.

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 'mutating working-state operation' label implies it is for bringing a draft into working state, and the statement that it does not commit a decision helps exclude decision/commit contexts. However, it does not explicitly say when to use this tool vs. alternatives.

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

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

Annotations already signal destructive and non-idempotent behavior, and the description adds meaningful context beyond that: it explains that the operation goes through the Design Flow semantic engine, changes authoritative state, and that failures preserve the draft. This is useful behavioral detail not present in 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 compact and front-loaded with the most important trait, 'Authority-changing operation.' Each sentence earns its place: classification, mechanism, and failure behavior are all covered without 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 no parameters and an existing output schema, the description covers the essential context: what the operation does, what it requires, and what happens on failure. The destructive annotation is present, and the description aligns with it. Nothing critical is missing for an agent to invoke this tool correctly.

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

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

The tool has zero parameters, so the description carries no parameter burden. The schema is trivially complete at 100% coverage, and the description appropriately focuses on operation semantics rather than parameters.

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

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

The description clearly identifies a specific operation: committing owner-approved draft state and changing authoritative project state. It distinguishes itself from read-only siblings like get_state or preview_round through the 'Authority-changing operation' framing, though it does not explicitly name a sibling.

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 states a clear precondition: 'Requires a complete valid draft.' This implies the tool should be used when an approved draft is ready to be made authoritative. However, it provides no explicit when-not-to-use guidance or named alternatives, leaving some inference to the agent.

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

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

Annotations already indicate readOnlyHint=false, but the description adds meaningful behavioral context: it is a mutating setup operation, it starts a session, and it creates no decision authority. This goes beyond the structured annotations and clarifies side-effect scope, though it does not discuss prerequisites, permissions, or failure behavior.

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

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

The description is compact and front-loaded: it opens with the operation category, states the concrete action, and closes with a non-obvious scope boundary about decisions and authority. Every sentence contributes distinct information with no filler.

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

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

Given the output schema and annotations, the description covers the core purpose and behavioral boundary well. However, with five parameters and zero schema descriptions, the lack of parameter guidance and absence of usage differentiation leaves notable gaps for an agent deciding how to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description provides no parameter-specific explanation. It does not clarify project_name, project_path, mode, project_id, or description beyond what the schema's property names already suggest, so it adds no meaningful 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 as a 'Mutating setup operation' that creates a project and starts its Design Flow session, giving a specific verb and resource. It also distinguishes the tool from decision-making siblings by stating it 'invents no decisions and creates no decision authority,' though it does not explicitly contrast with related tools like resume_project or import_draft.

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

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

The description implies the tool is for new project setup and starting a session, but it does not explicitly say when to use it over resume_project, import_draft, or other sibling alternatives. There is clear contextual framing but no direct when/when-not guidance or named 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 readOnly, idempotent, and non-destructive hints. The description adds valuable context beyond annotations: it is non-authoritative, does not commit any decision, requires an active draft, and uses the engine preview path only. This meaningfully discloses behavior and prerequisites.

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

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

Two concise sentences, front-loaded with the most critical trait ('Read-only simulation'). Every sentence contributes distinct information with 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?

With zero parameters, an output schema present, and annotations covering safety, the description fully contextualizes the tool. It adds the essential prerequisite (active draft) and clarifies the non-committal nature, leaving nothing critical 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?

The tool has zero parameters, so there is no parameter meaning to add. Per baseline, a 4 is appropriate because no semantic gaps exist for the agent to worry about.

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

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

States a specific verb and resource: 'Read-only simulation' for previewing a round. Also clarifies it is non-authoritative and 'does not commit any decision', distinguishing it from committing tools like lock_round.

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

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

The description clearly indicates this is for non-committal simulation and requires an active draft, giving an agent a clear condition for use. It does not explicitly name an alternative tool for when a commit is desired, but the 'does not commit' phrasing provides a strong implicit exclusion.

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. The description adds useful behavioral context by specifying exactly what is reported and stating that it changes no semantic authority, which reinforces the non-mutating nature without contradicting 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 two short sentences with no filler. The read-only and non-mutating nature is front-loaded, followed by a precise list of reported items.

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 status tool with an output schema present, the description fully covers what the agent needs to know: the tool is safe, non-mutating, and reports specific readiness-related data. No critical 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?

The tool takes zero parameters, so there are no parameter semantics to clarify. With 0 params, the baseline is 4, and the description appropriately focuses on the returned status information rather than parameter details.

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 (Report) and names concrete resources: adapter/engine versions, root confinement, and active-project status. This clearly differentiates it from sibling get-style tools like get_state and get_session_brief, which focus on session details rather than environment readiness.

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 tool's use case is implied: it is a read-only readiness/status check. However, there is no explicit guidance on when to use it versus siblings like get_state or get_session_brief, and no alternative is named.

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 convey read-only, idempotent, and non-destructive behavior. The description adds meaningful behavioral context beyond that: the recommendation is bounded, non-authoritative, and never starts a round. This provides useful nuance without contradicting 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?

Three short, focused sentences with the key qualifier 'read-only advisory operation' front-loaded. Every sentence adds distinct value and there is no redundant 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 advisory tool with an output schema and safety-related annotations, the description covers all essential behavioral information. Nothing else is needed for a correct call.

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

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

The tool accepts zero parameters, and schema description coverage is 100%, so there is no parameter ambiguity. The description appropriately focuses on behavior rather than parameters.

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

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

The description states the exact operation: returning the engine's bounded, non-authoritative recommendation. It also clarifies that the tool never starts a round, which helps separate it from state-changing siblings. It does not explicitly name alternative siblings, so it stops short of a perfect 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 implies when to use the tool: when a read-only advisory recommendation is needed. It does not explicitly state when to prefer alternatives such as preview_round, get_round, or readiness, so the usage 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.

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, and the description aligns with those by calling the operation mutating. It adds meaningful behavioral context beyond the annotations by stating that the tool 'never repairs invalid persisted state,' which is an important limitation an agent should know before invoking it.

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

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

The description is two sentences with no filler. The mutating/non-read-only nature is front-loaded, the core action is stated clearly, and the important caveat about not repairing invalid persisted state earns its place.

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

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

Given the tool has only one parameter, an output schema, and annotations covering safety hints, the description covers the essential behavior: mutating, resuming an existing project session, and not repairing invalid state. It does not detail what happens when validation fails, but the output schema likely captures that, so the description is sufficiently complete.

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

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

Schema description coverage is 0%, so the description must compensate for the single project_path parameter. It does clarify that the path must reference an existing engine project, but it does not add details about expected path format, validation behavior, or error conditions. This is minimal but adequate for a single-parameter 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 states a specific verb ('resume/start'), a specific resource ('Design Flow session'), and the prerequisite ('existing engine project'). It also identifies the operation as mutating, which distinguishes it from the read-oriented sibling tools like get_state and get_trace.

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

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

The description implies the tool is for resuming an existing project rather than creating a new one, but it does not explicitly name alternatives such as new_project or state when this tool should not be used. The phrase 'existing engine project' gives clear context, yet no explicit when-not guidance is provided.

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