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 useful behavioral context beyond annotations: plans/reviews are append-only, and the tool reads the latest task rather than a historical snapshot.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the verb, resource, scope, and source in a compact form.

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 values, and annotations cover safety, so the definition is usable for a no-argument call. However, the undefined optional parameters leave gaps in how to retrieve a specific task or iteration, making the tool incompletely specified for nuanced use.

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

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

Schema description coverage is 0%, and the description does not explain task_id or iteration. The word 'latest' hints at default selection behavior, but it does not clarify what each optional parameter controls, how they interact, or when to provide them.

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 read operation on the current/latest task plus its plans and reviews, anchored to application state. It is specific enough to distinguish from file and git reading siblings, though it does not explicitly name an alternative.

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

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

There is no guidance on when to use this tool versus siblings like workflow_status, read_file_range, or publish_plan. 'From application state' implies a context, but no explicit when-to-use or when-not-to-use instructions 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?

Annotations already establish readOnly and non-destructive behavior, so the bar for additional disclosure is higher. The description adds meaningful behavioral traits beyond annotations: 'bounded' implies pagination, 'filtered' implies scoping, and 'no-color' discloses output formatting. These traits are 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?

A single sentence that front-loads the core action and resource while every adjective ('bounded', 'filtered', 'no-color', 'bound workspace') earns its place by conveying a distinct constraint. No filler or redundancy.

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

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

With a rich output schema, safety annotations, and an input schema containing enums and bounds, the description does not need to explain return values or all parameter validation. It is complete enough for a read-only paginated diff tool, though it could add an explicit pointer about when to use git_status instead.

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 documenting the four parameters. It only hints at 'bounded' (cursor/maxBytes) and 'filtered' (path) without naming or explaining any parameter directly, and it does not clarify the mode enum or cursor format. The schema alone carries most of the semantic weight.

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

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

The description uses a specific verb ('Return') naming the resource ('Git diff page') with clear qualifiers: bounded, filtered, no-color, bound workspace. This distinguishes it from sibling tools like git_status (which reports state, not diffs) and read_file_range (which reads raw file content).

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 clear context for invoking a diff operation, but it does not explicitly state when to prefer git_diff over siblings like git_status or what conditions select this tool. Usage guidance is implied by the diff-specific resource rather than explicitly articulated.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds useful behavioral context beyond annotations by stating the result is 'bounded, filtered' and tied to the bound workspace, which informs agent expectations about output scope and size.

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 containing only essential information. Every word adds meaning, and there is no redundant restatement of the tool name or title.

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

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

The description is minimally viable for a simple read-only status tool, especially with an output schema available. However, it lacks explanation of the bounded/filtered semantics and how to use cursor and maxBytes, and it does not mention pagination or how the output is structured beyond the schema.

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 undocumented cursor and maxBytes parameters. The phrase 'bounded, filtered' hints at their purpose, but the description never names them or explains how they interact, such as using cursor for pagination.

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

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

The description uses a specific verb ('Return') with a clear resource ('Git porcelain status') and scopes it to 'the bound workspace.' It also distinguishes itself from the sibling git_diff by specifying status rather than diffs.

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 explicit guidance about when to use this tool versus alternatives like git_diff. It does not state exclusions, prerequisites, or contrast with any sibling tool, leaving the agent to infer selection 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 establish read-only, idempotent, non-destructive behavior. The description adds useful context beyond annotations: the result set is restricted to 'allowed' files and is 'bounded and paginated', which informs the agent about permission boundaries and pagination 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 two short sentences with no filler. The core purpose is front-loaded, and the pagination constraint appears immediately after, making it easy for an agent to parse 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?

For a simple listing tool with an output schema and strong annotations, the description covers the essential aspects: path scope, allowed-file boundary, and pagination. It does not explain cursor mechanics in detail, but the output schema and parameter constraints fill most gaps, so the definition is complete enough 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 must compensate. It clarifies that 'path' is workspace-relative and that results are bounded/paginated, which hints at 'limit' and 'cursor'. However, it does not explicitly explain how cursor pagination works or what the default limit behavior is, leaving some ambiguity.

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 ('List'), a concrete object ('allowed files and directories'), and a scope ('workspace-relative path'). This clearly distinguishes it from siblings like read_file_range (reading file contents) and search_text (searching contents), so an agent can understand the tool's role without opening the schema.

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 exploring allowed files and directories under a path, but it does not explicitly say when to use this tool versus alternatives such as workspace_info or read_file_range. The usage context is clear but no exclusions or sibling routing guidance is 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?

Annotations already provide idempotentHint=true and destructiveHint=false, but the description adds important context: it appends outside the workspace and never edits files or executes commands. This is meaningful because readOnlyHint=false, so the extra clarification of scope is valuable. 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 short sentences with no wasted words. The primary action is front-loaded, and the second sentence adds a valuable safety clarification.

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 plus annotations cover side effects and scope decently, and an output schema exists. However, for a tool with six required parameters and zero schema-level descriptions, the overall context is thin: it does not specify where 'outside the workspace' means, how validation works, or how idempotency is expected to be used.

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

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

Schema description coverage is 0%, and the description does not explain any of the six required parameters. The phrase 'validated plan record' gives high-level context, but leaves the semantics of fields like idempotency, baseCommit, iteration, and steps to inference.

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 ('Append') and a specific resource ('validated plan record outside the workspace'), which clearly distinguishes it from workspace-oriented siblings and from publish_review. It is not a tautology of the tool name.

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 validated plan needs to be persisted outside the workspace. It also hints at what it does not do ('never edits files or executes commands'), but it does not explicitly name alternatives or state when not to use this tool versus publish_review or other siblings.

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

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

The description adds a meaningful behavioral guarantee beyond the annotations: it never edits files or executes commands, clarifying the tool's side-effect boundary. The 'append' wording aligns with readOnlyHint=false and destructiveHint=false, and the idempotency key in the schema supports idempotentHint=true. 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?

Two short sentences with no filler. The primary action and key constraint are front-loaded, making it easy to scan while calling the tool.

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

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

For a tool with eight required parameters, nested objects, and zero schema description coverage, this description is too sparse to support correct invocation. It omits guidance on how to construct evidence, findings, idempotency, or verdict values, and does not explain the broader workflow context.

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

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

Schema description coverage is 0%, and the description only loosely refers to 'Git and test evidence' without explaining any of the eight required parameters, the nested evidence fields, idempotency, or verdict enum. It provides minimal semantic aid for an agent attempting to supply correct values.

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

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

The description clearly states the verb 'append', the resource 'review', and the binding to 'exact recorded Git and test evidence', distinguishing this review-writing tool from sibling publish_plan and read-only workspace tools. It is specific and actionable.

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 the tool to record a finalized review while explicitly saying it never edits files or executes commands, but it does not name alternatives or state when to prefer publish_review over publish_plan or other siblings. Exclusion is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful behavioral constraints: the file must be 'allowed workspace-relative' and UTF-8 text, and the read is 'bounded' to a line range, which is not captured in the structured annotations. It does not disclose error behavior or limits, but the added context justifies a 4.

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 entire description is one focused sentence with no filler. It front-loads the verb and states the core constraints immediately.

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 five parameters, no parameter descriptions, and no explanation of maxBytes/maxLines semantics in the description, the tool is not fully self-contained. The output schema and annotations cover return values and side-effect safety, but the range-bounding parameters remain ambiguous. A complete description would explain the optional bound parameters or the default behavior when none are supplied.

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 schema provides only bare types with no descriptions (e.g., endLine, maxBytes, and maxLines are $refs). The description mentions a 'bounded line range' and a file path, which supports path and start/end lines, but leaves maxBytes and maxLines undefined. An agent cannot determine how these parameters interact or which are required to bound the read.

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 ('Read') and a precise resource ('a bounded line range from one allowed workspace-relative UTF-8 text file'). This clearly distinguishes the tool from sibling list_files and search_text, which do not read file content. The scope and constraints are explicit.

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

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

The description implies the tool should be used when a bounded portion of a single file is needed, but it does not explicitly state when to prefer it over alternatives like list_files or search_text. No exclusions or differential guidance are provided, so an agent must infer usage from the verb and resource.

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 cover read-only, idempotent, and non-destructive behavior. The description adds useful context beyond annotations: regex is disabled for safety because repository text is untrusted, and the search is limited to allowed workspace files. 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 sentences with no filler; the core purpose and scope are front-loaded, and the rationale for regex rejection is concise. Every sentence contributes useful 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?

With 8 parameters and zero schema descriptions, this description is under-specified. It explains the primary literal-query constraint well but omits the semantics of path, case sensitivity, limits, and timeout, which an agent needs to use the tool correctly in varied scenarios.

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, but it only clarifies the query must be literal and bounded. It does not explain path, caseSensitive, maxResults, timeoutMs, maxFileBytes, or maxFiles, leaving most parameters ambiguous.

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

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

The description states a specific verb and resource: 'Search allowed workspace files' with a bounded literal query. It clearly distinguishes this from sibling tools like list_files and read_file_range by positioning it as text search, and it explicitly scopes the search to allowed files.

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 literal text searches and explicitly explains that regex is rejected, giving a clear 'when not to' signal. However, it does not mention alternatives or state when to prefer this tool over file listing or reading tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds the useful detail that the data lives outside the workspace, but it does not disclose behavior when no summary exists, authentication requirements, or failure modes. This is adequate but not rich.

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

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

One efficient sentence that front-loads the action and resource, with no filler or redundant restatement of the tool name. Every word contributes meaning.

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 and annotations cover return values and safety, but the description leaves parameter semantics and selection behavior unspecified. It is minimally adequate for a simple optional-parameter read tool, yet it has clear gaps that a richer description should close.

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

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

Schema description coverage is 0%, and the description does not explain task_id or iteration. The parameter names hint at their roles, but the agent cannot tell whether they filter, select, or override the 'last' summary, or how optionality interacts with the described 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 states a specific verb ('Read'), a precise resource ('last structured execution/test summary'), and a distinguishing scope ('outside the workspace'). This clearly separates it from the workspace-centric sibling tools 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 clear context for when to use this tool: when the latest structured test/execution summary from outside the workspace is needed. It does not name alternatives or exclusions, but the external-workspace framing makes the intended usage reasonably apparent.

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

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

The description adds a useful behavioral nuance ('derived') indicating the tool computes rather than returns raw stored state, and 'next safe action' suggests proactive analysis. Annotations already define the operation as read-only, idempotent, and non-destructive, so safety is covered. It does not disclose what happens when task_id is omitted, but the output schema may cover that.

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

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

The description is a single concise sentence with no filler. It front-loads the action and the key result fields. This is efficient, though it sacrifices completeness.

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?

While the read-only annotations and output schema reduce the burden, the description does not explain the optional task_id or differentiate from the closely related current_task sibling. An agent cannot tell when to use this tool instead of current_task without further information. The description is too thin for a tool that returns derived decision support.

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

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

Schema description coverage is 0% and the description does not mention task_id at all. It neither explains the parameter's meaning nor the behavior when omitted (the parameter is optional). The description therefore fully fails to compensate for the schema's lack of documentation.

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

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

The description states a specific verb ('Return') and the exact outputs: derived task phase, iteration limit, and next safe action. This clearly identifies the resource, though it does not explicitly distinguish from the sibling current_task. The title 'Read workflow status' reinforces the read operation.

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

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

No guidance is provided about when to choose workflow_status over siblings such as current_task or test_summary. The description is silent on context, prerequisites, or exclusions. An agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is well covered. The description adds value by clarifying the exact scope of what is returned and explicitly stating that source content is not included, which is a meaningful behavioral boundary beyond the annotations.

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

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

The description is a single, front-loaded sentence with no filler and every part adds information. The explicit negative statement is compact and useful.

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 no parameters and an output schema, so the description does not need to explain return values. It clearly states the two pieces of information returned and what is excluded, which is sufficient for an agent to invoke this simple informational 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 tool has zero parameters, so the description does not need to document parameter behavior. The schema already covers this completely, and the description correctly focuses on the purpose rather than inventing unnecessary 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 states a specific verb ('return') and resource ('bound workspace policy and Git identity'), and it explicitly excludes source content. This distinguishes the tool from siblings like list_files and read_file_range, which deal with source content.

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 a clear context: use it when you need workspace policy or Git identity information. The exclusion 'does not return source content' is useful guidance, though it does not explicitly name alternative tools or when-not scenarios.

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