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

No annotations are provided, so the description must carry the behavioral burden. It does disclose that the tool records the current phase as a resume target, which is important side effect. However, it doesn't describe what happens after blocking, how it affects other workflow operations, or any required permissions. Basic but not misleading.

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 and front-loaded with the core purpose in the first line, followed by concise parameter explanations. No wasted words, though the parameter list could be inline instead of separate lines, but overall it's efficient and well-structured.

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

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

Given the tool's complexity (3 params, no enums, no nested objects) and the presence of an output schema, the description covers the essentials: what it does and key parameters. However, it lacks guidance on side effects like whether blocking prevents other operations, and doesn't reference the output schema. Adequate but not comprehensive.

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 clarify parameters. It briefly explains 'reason' and 'owner' meaningfully, and 'project_dir' as default to working directory. This is enough to understand the purpose, but doesn't provide detailed syntax or format for each parameter. Scores a 3 because it adds some value beyond the schema.

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

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

The description states the verb 'Block' and the resource 'the workflow', and adds a key detail: 'Records the current phase as the resume target.' This distinguishes it from siblings like workflow_close or workflow_transition, though it doesn't explicitly name them. The purpose is clear and 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?

The description implies when to use (to block a workflow), but provides no exclusions or comparisons to alternatives like workflow_waive_guard or workflow_check. It gives the reason and owner but doesn't clarify when not to use this tool. Adequate but minimal guidance.

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

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

With no annotations, the description carries the burden. It explains the output (which transitions are ready/blocked) but does not explicitly state that it is non-destructive or has no side effects. It also does not mention prerequisites, error conditions, or behavior when no transitions exist. The read-only nature is implied but not stated.

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 plus an Args line, with no fluff. The purpose is front-loaded, and the parameter is explained in a structured way. Every sentence adds value.

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

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

Given the tool's simplicity (one optional param, output schema present), the description adequately covers the purpose, the parameter, and the return behavior. It does not explain edge cases or related sibling interactions, but these are not essential for a guard-check tool.

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

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

The only parameter, project_dir, is described as the project directory defaulting to the working directory. The schema only provides a default of null, so the description adds meaningful context about what the parameter represents and its default behavior. This compensates for the 0% 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 clearly states the tool runs guard checks for all transitions from the current state and returns which are ready or blocked with per-guard status. The verb 'check' and the specific resource 'transitions' make it distinct from sibling tools like workflow_transition (which performs transitions) and workflow_status (which shows status).

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 is a pre-flight check but does not explicitly state when to use it versus alternatives, such as 'use before workflow_transition' or 'use to debug guard failures'. No exclusions or alternative routing are mentioned, leaving the agent to infer the use case.

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

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

No annotations are provided, so the description must carry the behavioral burden. It discloses that force closes from non-stabilize phases and is 'logged as forced', but it does not describe the effects of closing (e.g., finality, impact on items, reversibility). For a mutation tool, this is insufficient.

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

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

The description is compact and directly states the purpose followed by parameter explanations. No unnecessary words or repetition.

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, so return details are handled. The description covers the normal usage context and the force option, but it omits broader context such as prerequisites, side effects, or what closing entails. Given no annotations, this is a moderate gap.

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 property descriptions (0% coverage), so the description compensates by explaining all three parameters: reason, force, and project_dir with its default. This is a clear addition over 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?

States a clear verb 'Close' and resource 'workflow', and notes the normal context 'from stabilize phase'. The action is unambiguous, though it does not explicitly differentiate from siblings like workflow_transition.

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

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

Mentions 'normally from stabilize phase' and the force parameter for non-stabilize phases, implying when it should be used. However, it does not explicitly state when NOT to use it or mention alternatives such as workflow_transition.

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 behavioral disclosure. It discloses the data sources ('.env and environment variables') and the useful provenance detail 'where they came from,' and 'Show/Returns' implies a read-only operation. It does not discuss precedence or side effects, but this is acceptable for a config inspection tool.

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

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

The description is concise and front-loaded: a one-sentence purpose, a one-sentence return summary, and a single line for the argument. Every sentence adds value and there is 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?

For a simple read-only tool with one optional parameter and an output schema, the description covers purpose, parameter, default, and the nature of the returned data. It could add explicit sibling routing or error/edge-case behavior, but an agent has enough to call 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 input schema provides only the parameter name and default with no description, so schema coverage is 0%. The Args block compensates fully for the only parameter: 'project_dir: Project directory. Defaults to working directory.' This adds both meaning and default behavior beyond the schema.

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

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

The description states a clear verb and resource: it will 'Show the active configuration from .env and environment variables' and 'Returns all PRODUCT_DELIVERY_* settings.' This makes the tool's scope unambiguous and distinguishes it from siblings like workflow_status or workflow_check even without naming 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 explicit when-to-use or when-not-to-use guidance is given, and no alternatives are mentioned. The intended use can be inferred from the purpose—inspect the effective config—but the description does not state how this differs from related workflow inspection tools.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that the tool returns the current state plus the action to take next, enumerates all four possible states with their conditions, and identifies legacy migration triggers. This is rich, accurate behavioral disclosure.

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

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

The description is front-loaded with the critical usage instruction and uses a structured, scannable list for states. Every sentence earns its place; there is 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?

For a tool with one optional parameter and an existing output schema, the description supplies invocation timing, parameter semantics, state enumeration, and follow-up actions. Nothing needed to call the tool correctly 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 single parameter, project_dir, has 0% schema description coverage, but the description fully compensates: 'Project directory to check. Defaults to working directory.' This adds meaning 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?

States a specific verb and resource: 'Detect the product-delivery state of a project.' It clearly differentiates itself from siblings by marking itself as the entry point to call FIRST and by routing to tools like workflow_setup, workflow_init, and workflow_status based on detected 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?

Explicitly tells the agent when to use it ('Call this FIRST when entering a project') and maps each possible return state to the appropriate alternative tool. This leaves no ambiguity about when to invoke this tool instead of a sibling.

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. It discloses that project_type can be defaulted via env and that from_migration detects existing files, but does not explain side effects like file creation or idempotency on re-initialization. The description adds some context but is not exhaustive.

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 well-structured, with a clear purpose sentence and an Args section that lists parameters. Every sentence earns its place, and the main verb is front-loaded.

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

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

Given an output schema exists, return values are covered. The description covers all parameters and mentions env defaults, but it does not address edge cases like re-initialization or prerequisites. It is sufficient for typical usage but lacks some contextual depth.

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

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

Schema coverage is 0%, so the description must compensate, and it does thoroughly. It explains all three parameters: project_type (greenfield/evolution, env default), from_migration (detect and migrate), and project_dir (defaults to working directory). This adds significant meaning beyond the bare 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 states a specific verb ('Initialize') and resource ('delivery workflow') and clarifies the project directory scope. It distinguishes from siblings like workflow_resume by focusing on new initialization, though it does not name alternatives explicitly.

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 for starting a new workflow and mentions project_type can be left empty for intake, but it does not contrast with sibling tools like workflow_resume or workflow_detect, nor does it specify when not to use this tool.

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

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

With no annotations present, the description carries the behavioral burden and does disclose meaningful behavior: the phase restriction and the postcondition that 'The item starts in "ready" state.' It does not describe failure modes or permissions, but the core side effect is clear and output schema covers return value details.

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 front-loaded with the primary purpose, followed by two key behavioral notes and a compact parameter list. Every sentence earns its place without verbosity.

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 4-parameter mutation tool with an output schema, the description covers all inputs, default behavior, phase validity, and initial state. It leaves phase semantics and failure behavior implicit, but the essential calling context is present.

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%, but the description compensates fully by documenting every parameter. It adds important semantic meaning, including the AC-NNN and RISK-NNN ID formats and the project_dir default behavior.

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 opens with 'Add a work item to the delivery plan,' a specific verb and resource that clearly defines the action. It distinguishes itself from sibling tools like workflow_item_transition and workflow_item_list by focusing on creation.

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 context constraint: 'Only valid in plan or deliver phase.' This tells the agent when the tool is applicable, though it does not explicitly mention alternative tools or when-not-to-use it.

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

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

With no annotations provided, the description carries the behavioral burden. It conveys a read-only list operation and discloses that project_dir defaults to the working directory, but it does not mention ordering, empty-result behavior, whether completed items are included, or how 'all' is scoped (project-level vs global). These are not severe gaps for a simple list tool, so it lands at a solid 3.

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 core behavior is stated in one front-loaded sentence, followed by an economical Args list with no filler or repetition. Every sentence earns its place, and the structure makes the optional filtering behavior immediately visible.

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 low-complexity list tool with two optional parameters and an output schema, the description covers the essential call semantics: what it lists, how to filter, and which directory it targets. The main omission is usage guidance relative to sibling workflow tools, but this does not prevent a competent agent from invoking 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%, so the description must fully compensate, and it does. state_filter is explained with concrete examples ('ready', 'implementing'), and project_dir is given both meaning and a default. Every parameter receives semantics beyond its raw type/nullable 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 uses a specific verb and resource: 'List all work items, optionally filtered by state.' It clearly identifies the operation and scope, which distinguishes it from mutation tools like workflow_item_add, workflow_transition, and workflow_item_waive. It stops one point short of 5 because it does not explicitly differentiate itself from read-like siblings such as workflow_status or workflow_check.

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 intended use is implied: call it when you need to list work items, optionally narrowing by state. However, there is no explicit guidance about when not to use it or which sibling tool to prefer for related queries such as overall workflow status or the next pending item. In a family of 18 workflow tools, this leaves some routing ambiguity.

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 disclosure burden. It does disclose the state-machine rules and that any item can be cancelled, which is useful. But it does not state what happens on an invalid transition (error vs silent no-op), whether changes are persisted immediately, or whether the mutation is reversible — meaningful gaps for a state-mutating tool with zero annotation coverage.

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?

Well-structured and front-loaded: the core action comes first, followed by the necessary transition map, then a compact Args block. The transition list is verbose but earns its place. No wasted sentences.

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

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

An output schema exists, so return values need no explanation. The transition map fully covers reachable states, but for a mutating tool with no annotations, the absence of invalid-transition behavior and post-transition consequences leaves the definition slightly incomplete for confident 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, and it partially does: it adds the WI-NNN format for item_id and the default for project_dir. However, it does not enumerate valid values for target (only implied by the transition map) and gives no elaboration on reason. The added value is real but thin.

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 clear verb+resource ('Transition a work item to a new state') and enumerates the exact valid transition map, which is highly specific. It does not explicitly distinguish itself from the sibling workflow_transition, but the 'work item' qualifier and state list imply scope. Minor deduction for not naming the sibling it differs from.

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 valid-transitions list provides implicit applicability guidance — an agent learns which target states are reachable from the current state. However, there is no explicit statement of when to choose this over workflow_transition or workflow_item_waive, and no exclusions for cases where the tool should not be used.

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 behavioral disclosure. It discloses the key side effect: the item moves to a 'waived' terminal state and counts toward the completion guard. It also states the prerequisite of approver/reason. It does not mention reversibility, permission requirements, or other side effects, but the disclosed information is sufficient for basic safe use.

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 well-structured: a single introductory sentence states the purpose, followed by a sentence on prerequisites and state effect, then a compact Args list. Every sentence adds value, and the most important behavioral details are front-loaded. No fluff or repetition.

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 (4 params, one optional) and the presence of an output schema, the description covers the essential aspects: purpose, state change, guard interaction, and parameter semantics. It does not explain error conditions or behavior when the item is not in reviewing state, but those are likely handled by the tool itself. Overall, the description provides enough context 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?

Schema description coverage is 0%, so the description's Args section is essential. It provides meaningful semantics for all four parameters: `item_id` gets a format hint (WI-NNN), `approver` and `reason` get clear contextual definitions, and `project_dir` is described as defaulting to the working directory. This goes far beyond the schema's bare type/title information.

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 opens with a specific, action-oriented definition: 'Waive a work item that is in reviewing state.' It clearly identifies the resource (work item), the action (waive), and the applicable state. It also distinguishes the tool from siblings like workflow_item_transition by stating the terminal 'waived' state, making its purpose unambiguous.

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 constrains usage to items in 'reviewing state' and states prerequisites: requires an explicit approver and reason. This gives clear context for when the tool should be used. It does not name alternative tools for non-waive transitions, so it falls short of explicit when-not/alternative guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. 'Show' and 'Returns' convey a read-only query with no mutation, and the description explains what the output contains. It could be more explicit about side effects or failure behavior, but the core transparency is solid.

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 appropriately short and front-loaded: purpose, return semantics, then the parameter line. Every sentence earns its place and there is 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?

For a tool with one optional parameter and an output schema, the description is essentially complete: it states what is returned, why to use it, and the parameter default. It does not guide the agent toward sibling tools explicitly, but that is a minor gap.

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 free-text description is the only source of parameter meaning. It fully covers the sole optional parameter by identifying project_dir as the project directory and specifying its default as the working directory.

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 opens with a specific verb and resource: 'Show allowed transitions from the current state with guard status.' This clearly distinguishes it from action-oriented siblings like workflow_transition and state-only tools like workflow_status.

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 'so the agent can decide what to do next' gives clear decision context for when to call the tool. It does not explicitly name alternatives or exclusions, but the intended usage is evident and not misleading.

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 reasonably carries the behavioral burden. It clearly discloses that the operation does not affect files on disk and only mutates the tracking list lagrange. It does not mention error behavior or reversibility, but the main side-effect boundary is well communicated.

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 very short, front-loaded with the core action, and uses the second sentence to add an important boundary. The Args section is minimal and directly tied to the only parameter without any fluff.

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 adequately covers the tool's basic purpose and non-destructive nature, and the output schema likely handles return details. However, it leaves important operational context unresolved, such as how project_dir should be formatted and what happens if the project does not exist in the registry. These gaps matter because there are no annotations to supply behavioral details.

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 parameter. The only parameter guidance is "project_dir: Project directory to remove," which essentially restates the schema title and adds no format, path-resolution, or identifier semantics. An agent cannot tell whether this should be an absolute path, relative path, or registered project key.

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 and resource: "Remove a project from the registry." It further clarifies the exact scope by saying it "does not delete any files — just removes the project from the cross-project tracking list," which distinguishes it from file-deletion tools and other workflow siblings.

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

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

The intended use is clear from the opening sentence and the registry/tracking-list context. The explicit caveat that it does not delete files provides a useful non-goal boundary, though it does not name alternative tools or state precise conditions for choosing this tool over a sibling.

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

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

No annotations are provided, so the description must carry the behavioral burden. It does disclose useful behavior: cached vs. live refresh, reading state from disk, and the phase/timestamp fields shown. However, it does not mention potential side effects of refresh (e.g., cache updates), performance costs, or failure behavior, so it 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?

The description is compact and front-loaded with the primary action, followed by a clarifying sentence and focused parameter semantics. Every sentence adds meaningful information, and there is no filler or repetition of schema details.

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

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

Given a single optional parameter and an existing output schema, the description is largely complete: it states the output scope, the fields shown, and the refresh behavior. The main gap is the lack of guidance on when to use this tool in relation to its many siblings, but the tool is simple enough that this is a minor omission.

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 provides only a boolean refresh with a default, so schema coverage is effectively 0%. The description fully compensates by explaining exactly what refresh=True and refresh=False do, including the trade-off between live state and speed. This is a clear value-add beyond the structured 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 starts with a specific verb and resource: 'List all known projects managed by this server.' It clarifies scope by noting it shows projects that were 'detected, initialized, or set up,' which helps distinguish it from more targeted tools. However, it does not explicitly reference any sibling tool to differentiate itself, 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 explains the refresh parameter's behavior but does not say when to use this tool versus alternatives like workflow_status, workflow_detect, or workflow_init. There are no explicit when-to-use or when-not-to-use conditions. The context is only implied by the wording 'List all known projects.'

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 behavioral burden. It says what is rendered (a markdown summary) but not whether it returns a string, writes a file, requires an initialized workflow, or has any side effects. This is a significant gap for a tool that could plausibly mutate or generate artifacts.

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 directly informative. One sentence conveys the purpose, and one argument line documents the sole parameter with 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?

For a simple tool with one optional parameter and an output schema, the core purpose and parameter are covered. However, the absence of usage context and behavioral expectations—especially how it relates to workflow_status and whether it is read-only—leaves meaningful gaps that annotations could have filled.

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 documents the only parameter: 'project_dir: Project directory. Defaults to working directory.' This adds meaningful semantic context beyond the schema's type/default and fully covers 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 states a specific verb ('Render') and a distinct output ('human-readable markdown summary of the workflow status'). This is clear and distinguishes it from a raw status tool like workflow_status, though it does not explicitly name or contrast 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 given on when to use this tool versus alternatives. There are no exclusions, prerequisites, or references to sibling tools such as workflow_status or workflow_check, leaving the agent to infer the appropriate 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 of behavioral disclosure. 'Resume a blocked workflow back to its pre-blocked phase' describes the intended effect but omits what happens if the workflow is not blocked, whether the operation is reversible, whether the reason is validated, or what the response contains. For a state-mutation tool with zero annotation coverage, this is a significant 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?

Extremely efficient: one front-loaded purpose sentence followed by a compact args list. Every sentence earns its place with zero filler. The purpose is stated first, which is the ideal structure for an agent scanning quickly.

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?

Although an output schema exists and both parameters are documented, this is a state-mutation tool with no annotations and no behavioral disclosure. The description omits error conditions (e.g., resuming a non-blocked workflow), prerequisites (must the workflow currently be blocked?), and post-conditions. For a tool that changes workflow state, the agent needs more than 'resume' to call 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%, but the description documents both parameters: reason ('Why the blocker is resolved') and project_dir ('Project directory. Defaults to working directory.'). This compensates for the missing schema descriptions. However, the reason parameter's meaning is thin — it doesn't clarify whether it is required, whether it affects the transition, or what format is expected.

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 (resume) and resource (blocked workflow), and specifies the outcome (return to pre-blocked phase). This distinguishes it from siblings like workflow_block, workflow_waive_guard, and workflow_transition without naming them explicitly. It doesn't name the sibling it is not, but the action is specific enough that an agent can tell it apart from the block/transition family.

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 'blocked workflow' implies the tool is for unblocking, but there is no explicit when-to-use guidance, no exclusions, and no named alternatives. It never states when not to use it or which sibling to pick instead (e.g., workflow_waive_guard for waiving a guard without resuming). Usage context 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?

No annotations are provided, so the description correctly carries the full burden. It discloses idempotency ('safe to run multiple times'), non-destructive merging ('Merges into existing files without clobbering other settings'), and the set of files it creates or updates. This is meaningful behavioral context beyond what any schema would reveal. It doesn't address permissions or reversibility, but for a file-generation tool the disclosed properties are the critical ones.

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?

Well-organized and front-loaded: a one-line purpose, a file list, two behavioral guarantees, then usage guidance and Args. Every sentence earns its place and the dry-run workflow is stated before the parameter documentation. Slightly longer than strictly necessary, but nothing is redundant.

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 an output schema exists (so return values are covered elsewhere), the description is thorough: it names the target files, guarantees idempotency and non-destructive merge behavior, prescribes the dry-run-then-apply workflow, and documents both optional parameters. The only omission is guidance on when to prefer a sibling tool, which is a usage-guidelines concern rather than a completeness gap.

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 fully compensate, and it does. Both parameters are documented in the Args section: dry_run ('preview what would change without writing. If False, apply the changes') and project_dir ('Project directory. Defaults to working directory'). The description even clarifies default behavior that matches the schema defaults. This is exemplary compensation for a schema with zero inline descriptions.

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

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

The description opens with a specific verb and resource: 'Set up product-delivery in a project,' then enumerates the exact files affected (.claude/settings.json, .cursor/mcp.json, AGENTS.md, .env.sample, .env, .gitignore). This is concrete and action-oriented. It loses a point because it does not explicitly distinguish itself from the sibling workflow_init, which could plausibly overlap in 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?

Provides a clear usage sequence: 'Call with dry_run=True first to preview changes, then with dry_run=False to apply them. Present the preview to the user before applying.' This is explicit context on how to invoke it safely and the expected interaction pattern. However, it never names alternatives or says when NOT to use this tool among the 17 siblings, so exclusions are missing.

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 verb 'Get' implies a read-only operation, which is the main behavioral trait, but the description does not state this explicitly or mention prerequisite conditions (e.g., an initialized workflow) or failure modes. Since no annotations are provided, the description carries the full burden and only partially meets 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?

One purpose sentence followed by a single parameter definition; no filler or repetition. The key behavior is front-loaded and every sentence adds value.

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

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

The output schema covers return structure, and the one optional parameter is documented, so the description is close to adequate for a simple status read. It is incomplete mainly because the large sibling family and lack of usage guidance are not addressed, though that is partially captured by 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?

With 0% schema description coverage, the description supplies the only semantic explanation for project_dir and clarifies the default behavior ('Defaults to working directory'). It could add path-format details, but for a single optional parameter this is mostly sufficient.

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 specific action ('Get') on a clear resource ('current workflow state, work items, and recent events'), going well beyond a tautology. It does not explicitly name a sibling it is not, so it stops 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?

There is no statement of when to use this tool over related workflow_check, workflow_item_list, or workflow_render. With 18 sibling tools, an agent is left to infer the decision boundary from names 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does mention automatic guard checking, forced transitions being logged as forced, and attaching evidence. This gives some transparency about side effects. However, it does not describe the success/failure behavior, whether the transition is idempotent, what happens to existing state, or any prerequisites. For a mutation tool, this is partial coverage.

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 concise docstring with a clear opening statement followed by a bulleted argument list. It front-loads the core purpose and then details parameters without redundancy. Every sentence adds value—no filler or repetition. It is appropriately sized 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 an output schema (not shown) and no annotations, so the description must cover behavioral context. It explains guards, force, and evidence, but lacks details on return values, state machine semantics, or how it integrates with the overall workflow. With many siblings, it would benefit from clarifying its role in the lifecycle. The description is functional but not fully comprehensive for an agent to know all consequences.

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 explains each parameter: target with examples, evidence as keys to attach, force as bypassing guards, reason as human-readable, and project_dir with default. This adds meaning beyond the schema's bare titles. It does not specify the exact format of evidence keys or reason string constraints, but it covers the essential semantics for all five parameters.

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

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

The description clearly states the tool's purpose: 'Attempt a state transition.' It specifies the verb (attempt) and the resource (state transition), and provides concrete examples for the target parameter. This distinguishes it from siblings like workflow_status (read-only) and workflow_next (which likely moves to a predefined next step). The purpose is unambiguous.

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 explicit guidance on when to use this tool versus alternatives. With 17 sibling tools covering various workflow operations, the description does not mention when to prefer workflow_transition over workflow_next, workflow_item_transition, or workflow_waive_guard. The usage context is implied (state transitions) but not clearly scoped, and no exclusions or alternative recommendations are provided.

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 disclose that the waiver is recorded with approver and reason, and that the guard will show as 'waived' instead of 'fail' on subsequent checks. However, it omits other relevant behaviors like reversibility, permission requirements, or whether the transition proceeds automatically, so it provides only partial 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 compact and well-structured: a clear opening statement, a few behavioral details, then a bulleted Args list. Every sentence adds value, though the format could be slightly tightened without losing 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 4-parameter tool with no annotations and an output schema present, the description covers the core behavior, parameter semantics, and the effect on checks. The main gap is the ambiguous relationship with workflow_transition—whether the transition is automatically executed or only unblocked—but this is partially inferable from the tool name and siblings. Overall, an agent can likely use it correctly with the provided information.

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 this effectively: guard is tied to workflow_check results, approver defines who approved, reason explains risk acceptance, and project_dir notes default to working directory. This adds real meaning beyond the raw schema types and required flags.

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 first line 'Waive a transition guard so the transition can proceed' uses a specific verb and resource, clearly distinguishing it from sibling tools like workflow_check (which checks) and workflow_transition (which performs the transition). The description is explicit about the action and its effect.

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 implicitly places the tool after workflow_check results and before a transition, but it never explicitly states when to use it vs. alternatives or when not to use it. There is no direct comparison to workflow_item_waive or workflow_transition, leaving the selection decision partially to inference.

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