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

Annotations already establish readOnlyHint=false and destructiveHint=false; the description goes further by disclosing recursive creation ('multiple nested directories in one operation'), the sandbox boundary, and automatic path normalization. It still omits what happens on failure or what the call returns, keeping it short of a 5.

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 statements are front-loaded and clear, but the path paragraph is redundant — it asserts 'Absolute paths are the most reliable' and then repeats 'Absolute paths are generally the most reliable' a few lines later. The trailing 'DC: ...' branding sentence consumes space without adding selection or invocation value.

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

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

For a one-parameter mutation tool with no output schema, the description covers the essentials: recursion behavior, sandbox restriction, and path handling. The absence of any statement about the return value or error behavior is a minor gap given there is no output 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?

The single path parameter has 0% schema description coverage, so the description must compensate, and it does: absolute vs relative behavior, tilde-path caveats, slash-direction normalization, and cwd dependence. The only gap is that it never says whether the path is a file or directory target beyond the tool's own purpose.

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 ('Create a new directory') and adds a meaningful nuance ('or ensure a directory exists') that signals idempotent behavior. It does not name any sibling, but unlike list_directory or move_file the action is unambiguous from the text alone.

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

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

It gives a real constraint ('Only works within allowed directories') and path-format advice, which implies suitable contexts, but it never states when to prefer this tool over alternatives such as write_file creating parent paths, nor does it name any sibling. Usage is inferable 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 destructiveHint=true and readOnlyHint=false, but the description adds substantial context beyond that: default single-occurrence replacement, expected_replacements semantics, the uniqueness requirement for matching, a character-level diff on near-matches, the configurable fileWriteLineLimit warning, and DOCX XML repacking behavior. This is rich behavioral disclosure that annotations alone cannot convey.

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

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

The purpose and core editing rules are front-loaded, and the format-handling sections are genuinely useful for a polymorphic tool. However, it is verbose and contains redundancy, notably restating absolute-path reliability twice and repeating the single-replacement default in two places, which dilutes an otherwise well-structured description.

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 complex 8-parameter tool with no output schema and 0% schema coverage, the description is substantially complete: it explains the three editing modes, the uniqueness/replacement model, failure feedback, and path handling. The main gap is the undocumented 'origin' enum and 'options' object, which an agent cannot interpret from any source.

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 carry the burden, and it does for most parameters: file_path, old_string, new_string, expected_replacements (with default 1), range (with FROM:TO format and examples), and content (2D array format). It leaves 'origin' (the one enum) and 'options' (nested object) undocumented, so it falls short of full coverage despite strong compensation.

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+resource ('Apply surgical edits to files') and immediately differentiates from the sibling write_file by contrasting small focused edits against 'large multi-purpose replacements.' It further distinguishes itself as a polymorphic editor by enumerating the file types it handles (Excel, text, DOCX), so an agent can identify it 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?

Gives concrete usage context: prefer small focused edits, use separate edit_block calls for multiple sections, include minimal surrounding context, and route by extension to the correct parameter mode. It does not explicitly state when to choose a sibling like write_file instead, but the implied split (surgical edits vs. full-file write) is clear.

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

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

The description identifies the tool as destructive, matching annotations, and specifies it targets a 'terminal session'. However, it does not disclose required permissions, potential side effects, or how termination is performed.

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, no redundancy. The second sentence about referencing is marginally useful but still concise.

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

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

Lacks explanation of what constitutes a terminal session, how to obtain a PID, and how this tool differs from the similar 'kill_process'. The presence of siblings demands more 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?

The description does not mention the 'pid' parameter or how it identifies the session. With 0% schema coverage, the description fails to clarify the parameter's meaning or format.

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 it force terminates a running terminal session, but it does not differentiate from the sibling tool 'kill_process', which likely has similar functionality.

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 on when to use this tool versus alternatives like 'kill_process' or 'interact_with_process'. The only additional note is about referencing the command, not usage 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered structurally. The description adds that the payload includes clientHistory, systemInfo, and allowedDirectories, hinting at potentially sensitive content, but says nothing about permissions, redaction, or side effects beyond that. With annotations carrying the safety burden, 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?

The main statement is front-loaded and the bulleted field list is an efficient way to enumerate a return shape that has no output schema. The closing sentence about 'DC: ...' / 'use Desktop Commander to ...' is orientation fluff that does not help an agent invoke this 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?

With no output schema, the enumerated config fields are the only documentation of the return value, and they cover all ten fields plus two defaults (1000 and 50), which is genuinely useful. The gaps are the undocumented `origin` parameter and no note on how often config changes or whether the read is cached.

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

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

Schema description coverage is 0% and the description never mentions the single `origin` parameter or its `ui`/`llm` enum. The schema must carry that burden entirely, and while the enum values are fairly self-explanatory, the description does nothing to explain what difference the origin makes.

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 ('Get the complete server configuration as JSON') and enumerates exactly what the configuration contains, so an agent knows precisely what this returns. It never differentiates itself from the obvious sibling set_config_value, whose job is the inverse (writing config), 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 call this versus alternatives such as get_usage_stats or get_recent_tool_calls, and no mention of set_config_value as the mutating counterpart. The trailing note about 'DC: ...' phrasing is about how to reference Desktop Commander in instructions, not about when this tool is appropriate.

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

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

Annotations already establish readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description usefully adds the sandbox constraint ('Only works within allowed directories') and path-normalization behavior, though it says nothing about error behavior for missing files.

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 field list is front-loaded and scannable, but the path guidance is padded — 'Absolute paths are the most reliable' appears twice in different words, and the 'DC: ...' / 'use Desktop Commander to ...' line is boilerplate that does not help tool selection.

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

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

With no output schema and zero schema description coverage, the description carries the load well by enumerating every returned field (including file-type-specific ones like sheets and appendPosition) and covering path-format caveats. The main remaining gap is failure behavior inside the allowed-directories constraint.

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% — the single 'path' parameter has no description in the schema — but the description compensates with substantive guidance: absolute paths are most reliable, paths are normalized regardless of slash direction, relative paths depend on cwd, and tilde paths may not resolve. Format details (e.g., whether paths must exist, directory vs file handling) are still absent.

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?

Opens with a specific verb+resource ('Retrieve detailed metadata about a file or directory') and enumerates the exact fields returned, so an agent can distinguish it from read_file or list_directory 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?

States a constraint ('Only works within allowed directories') but never says when to choose this over siblings like read_file or list_directory, nor when it is the wrong tool. Usage is implied rather than specified.

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 the safety profile (readOnlyHint, destructiveHint=false), so the bar is lower. The description adds real behavioral detail beyond that: tail behavior for negative offsets, that length is ignored in that case, and that it returns only the specified range plus search status.

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?

Purpose is front-loaded and the examples genuinely earn their place by disambiguating offset/length interactions. There is minor waste in the heavy indentation and the trailing boilerplate about 'DC: ...' referencing.

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

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

With no output schema, the description usefully states what is returned (the range plus search status). Pagination semantics are fully covered; the only gap is where sessionId originates and what the search status values mean.

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 carry parameter meaning, and it does so thoroughly for offset and length with four concrete examples including negative-offset edge cases. The required sessionId parameter, however, is never explained (presumably from start_search).

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 ('Get more results from an active search') and scopes it to pagination continuation. It is clearly distinguishable from start_search (which initiates) and from read_process_output (which it explicitly compares itself to).

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 describes the workflow: 'call this repeatedly to get progressive results from a search started with start_search.' It gives clear context for when to invoke it but does not state when not to use it (e.g., vs. list_searches or stop_search).

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/openWorld=false/destructive=false, yet the description adds substantial behavior beyond them: it excludes its own calls and track_ui_event, names the persistence file, states the 1000-call in-memory cap, notes disk trimming, and discloses the 4 KiB output omission marker. That is exactly the kind of context annotations cannot carry.

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?

Front-loads the core behavior, then structures the rest into a short bullet list and a compact behavior note. The trailing line about being referenced as 'DC: ...' is meta rather than functional for selection, but overall it is tight and every functional sentence earns its place.

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

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

For a read-only history reader with no output schema and no siblings to distinguish, the description covers what it returns (chronological argument/output list), storage lifetime, size limits, and self-exclusion. The only real gap is parameter meaning, which is a separate dimension.

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 none of the three parameters (since, toolName, maxResults) are mentioned in the description. The phrase 'recent' vaguely hints at date ordering, but there is no explanation of filtering by tool name, the date format, or the result cap, so the description does not compensate for the coverage gap.

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+resource ('Get recent local tool call history with arguments and outputs') and clarifies returns a chronological list from a local history file. No sibling covers call history, so there is no overlap to disambiguate, but it also does not explicitly contrast with any sibling.

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

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

The 'Useful for' bullets give concrete contexts (onboarding chats, recovering context after history loss, debugging tool call sequences), which is clear usage guidance. It lacks an explicit when-not-to-use or alternative-tool clause, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds value by disclosing the return content (usage summary, success/failure rates, performance metrics) — useful since no output schema exists — but it says nothing about scope limits or time windows.

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 first two sentences are efficient and front-loaded, but the third sentence about 'DC: ...' / 'use Desktop Commander to ...' referencing is boilerplate meta-instruction that adds no selection or invocation value.

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

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

For a zero-parameter, read-only, closed-world tool with no output schema, the description covers purpose, return content, and use context adequately. Only the lack of any scoping details (time range, filters) leaves 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?

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to clarify beyond what the empty schema already conveys.

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+resource ('Get usage statistics') and enumerates what is included (tool usage, success/failure rates, performance metrics), distinguishing it from the similar get_recent_tool_calls sibling. However, it never names that sibling or explicitly delineates the boundary, 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 phrase 'for debugging and analysis' implies a usage context but gives no when-to-use, when-not-to-use, or alternative-tool guidance against siblings like get_recent_tool_calls. Usage is only weakly implied.

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?

Beyond the annotations (readOnlyHint=false, openWorldHint=true), the description discloses that a browser is launched and that usage metadata is automatically attached to the submission (tool_call_count, days_using, platform, client_id) — privacy-relevant behavior an agent could not infer from structured fields. This is exactly the added context the dimension rewards.

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 purpose and the metadata disclosure are front-loaded and each sentence carries information. The trailing note about 'DC: ...' invocation phrasing is marginally useful for agent behavior but is the one element that reads as boilerplate rather than necessary content.

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

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

For a zero-parameter, no-output-schema tool whose side effect is launching an external browser, the description covers everything an agent needs: what it opens, that it takes no arguments, what data is transmitted, and that responses cannot be supplied. Nothing material 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?

With zero parameters, the baseline is 4, and the description reinforces the schema by stating 'No input parameters are required,' which matches the empty properties object with additionalProperties=false. There is no syntax or format to add.

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 ('Open feedback form in browser to provide feedback about Desktop Commander') and is unmistakable against every sibling, none of which relate to feedback collection. It also draws a clear boundary by noting the tool does not accept or pre-fill survey responses.

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 usage context is clear and self-selecting: this is the tool to call when the user wants to give feedback. The description explicitly rules out one wrong expectation (that you can pass survey answers through this tool), but it names no alternatives or conditions for when not to call it, which keeps it below a 5.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds substantial behavioral context beyond that: smart prompt-waiting, error/completion detection, early exit, prompt-text cleaning, and verbose timing telemetry. It does not itself warn that arbitrary input can be destructive, but the annotation carries 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?

Front-loaded with purpose, then organized under SMART DETECTION, PARAMETERS, and PERFORMANCE DEBUGGING headers, which is easy to scan. Minor waste exists: the example bullets partly restate the 'useful for' sentence, and the trailing 'DC: ...' branding line adds no invocation 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?

No output schema exists, and the return description ('execution result with status indicators') is thin, but the smart-detection section compensates by explaining cleaned output, error detection, and early exit. For a 5-param interactive mutation tool with annotations covering safety, this is close to complete.

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

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

Schema description coverage is 0%, so the description must carry the load, and it does: it documents all five parameters (pid, input, timeout_ms, wait_for_prompt, verbose_timing) and gives defaults (8000ms, true, false) plus semantics for each. The pid is tied back to start_process, which adds real meaning.

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 ('Send input to an existing terminal or REPL process and return newly available output') and distinguishes itself from the sibling start_process() it depends on. An agent can tell it apart from read_process_output and start_process without opening any 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?

Gives clear context for when to use it: interactive shells, Python/Node/R/Julia REPLs, database consoles, and long-running commands started with start_process(). It names the prerequisite (start_process) but offers no explicit when-not guidance or alternatives (e.g., read_process_output for passive reading).

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 set destructiveHint=true, so the description's 'forcefully terminate' adds some context but does not disclose additional behaviors like potential data loss or irreversibility. It aligns with annotations but adds little extra.

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

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

Three sentences, mostly concise. The third sentence about referencing as 'DC: ...' is tangential and adds length without aiding tool invocation.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose and caution adequately. However, it could include a brief note on prerequisites (e.g., PID must exist) for completeness.

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

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

Schema has 0% description coverage; the description only mentions 'by PID' without explaining what PID means or how to obtain it. This adds minimal value beyond the parameter name.

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 'Terminate a running process by PID.' This is a specific verb-resource pairing that distinguishes the tool from siblings like 'interact_with_process' or 'force_terminate'.

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?

While the description warns 'Use with caution', it does not specify when to use this tool versus alternatives (e.g., 'interact_with_process' for graceful termination) or when not to use it. No explicit context or exclusions 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 cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), and the description goes well beyond them: it discloses context-overflow protection with the 100-item nested cap, the [WARNING]/[DENIED]/[NOT_FOUND] markers, depth-controlled recursion, and path normalization behavior. This is exactly the extra runtime context an agent needs.

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?

Front-loads purpose, then behavior, examples, and constraints in a scannable order. It is somewhat long, and the closing paragraph repeats the 'absolute paths are most reliable' point twice and appends a promotional 'DC: ...' reference line that does not earn its place, but the bulk of the text is substantive.

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?

There is no output schema, so the description must explain the return format, and it does so thoroughly with a worked depth=2 example plus status markers. Combined with depth and path semantics, an agent has everything required to call it correctly within allowed directories.

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 schema coverage at 0%, the description carries the burden and mostly succeeds: it fully explains 'depth' (default 2, with concrete 1/2/3+ semantics) and 'path' (absolute vs relative, tilde resolution, slash normalization). The 'origin' enum parameter is left unexplained, which is the one remaining gap.

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 ('Get a detailed listing of all files and directories in a specified path') and clarifies it operates 'without starting a shell command,' which distinguishes it from process/shell siblings. An agent can immediately tell this apart from read_file, get_file_info, or the search 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?

Usage is implied by the purpose and by the constraint 'Only works within allowed directories,' and the 'without starting a shell command' line hints at an alternative approach. However, it never explicitly states when to choose this over sibling discovery tools like start_search or read_multiple_files, nor does it give when-not guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds value beyond that by enumerating the returned fields (PID, command name, CPU, memory), which matters because there is no output schema.

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 purpose and return-value sentences are front-loaded and efficient, but the trailing sentence about 'DC: ...' / 'use Desktop Commander to ...' is boilerplate that does not help an agent select or call this tool, and the block carries excess indentation and whitespace.

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

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

For a no-argument, read-only listing tool with full annotation coverage, the description supplies the essentials: what it lists and what the results contain. Missing only a note on result volume or ordering, which is minor given there is no output 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The absence of arguments is consistent with the empty schema and the read-only listing 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?

States a specific verb and resource ('List all running processes') and clarifies scope with 'all', which separates it from read_process_output/interact_with_process on a single process. It does not explicitly name a sibling or contrast with one, so it falls short of the top mark.

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 when-to-use guidance, no prerequisites, and no routing to alternatives like list_sessions or get_usage_stats. The only hint is the meta-instruction about referring to 'Desktop Commander', which addresses invocation phrasing rather than tool selection.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds value by disclosing the returned fields and that it lists only active searches, compensating for the absence of an output schema.

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?

Front-loads the core action and return contents efficiently. The trailing note about referencing it as 'DC: ...' is invocation boilerplate that does not help tool selection, a minor blemish on an otherwise tight description.

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

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

For a zero-parameter, read-only list tool with no output schema, the description is complete: it states the action, scopes it to active searches, and enumerates the returned fields. An agent has everything it needs 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 tool takes zero parameters, which sets the baseline at 4. There is nothing for the description to clarify beyond the fact that it operates on all active searches with no filtering options.

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 ('List all active searches') and enumerates the fields it returns (IDs, types, patterns, status, runtime). It names list_sessions as an analogous sibling but does not explicitly distinguish itself from search siblings like start_search, stop_search, or get_more_search_results.

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?

'Useful for managing multiple concurrent searches' implies a context of use, but there is no explicit when-to-use vs. alternatives guidance (e.g., versus get_more_search_results or stop_search) and no exclusions. Usage is inferred rather than stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds genuinely new behavioral context by explaining what each returned field means and how to interpret blocked/stuck sessions, going 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?

Front-loads the purpose well and uses scannable bullets, but the closing line about being referenced as 'DC: ...' is instruction-level metadata that does not help an agent select or invoke this specific tool, and the field list slightly overlaps the debugging heuristics.

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?

There is no output schema, so the description rightly compensates by documenting the returned fields and their interpretation. For a parameterless read-only listing tool, nothing an agent needs in order to call it correctly appears to be missing.

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

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

The tool takes no parameters (empty object schema, additionalProperties false), so there is nothing for the description to clarify; the baseline for a zero-parameter tool is 4.

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 ('List all active terminal sessions') and enumerates the returned fields (PID, Blocked, Runtime), so the agent knows exactly what this tool surfaces. It does not explicitly distinguish itself from the nearby list_processes or interact_with_process siblings, which keeps it just short of a 5.

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

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

Provides concrete when-to-use guidance: verify sessions are running before sending input, and interpret 'Blocked: true' / long runtimes as signals of a stuck REPL. It lacks an explicit 'use X instead when Y' routing statement naming an alternative, so it stops short of the top score.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context: the allowed-directory restriction and path normalization/reliability quirks. It does not, however, explain whether an existing destination is overwritten or what happens on failure.

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 purpose is front-loaded and clear, but the path guidance is repetitive—'Absolute paths are the most reliable' essentially appears twice—and the 'DC: ...' / 'use Desktop Commander to ...' boilerplate adds no task value.

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

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

For a destructive two-parameter operation with no output schema, the description covers path handling and scope but omits key behaviors: overwrite semantics, error/failure conditions, and permission requirements. Annotations carry the destructive signal, but more operational detail would help.

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 both parameters. It does meaningfully: it explains that source and destination are paths, must reside in allowed directories, are auto-normalized, and that absolute paths are most reliable. That is solid path semantics beyond the bare 'string' types.

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 (move/rename) and resource (files and directories), and clarifies the dual behavior of moving between directories and renaming in a single operation. This is unambiguous and clearly distinguishable from siblings like write_file or create_directory.

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 prerequisite ('both source and destination must be within allowed directories') but never states when to prefer this over alternatives, nor names any sibling tools. Usage context is only implied.

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?

Beyond the readOnly/openWorld annotations, the description discloses a great deal: directory allow-listing, URL-is-read-in-full-regardless-of-pagination, reverse-read/byte-estimation performance behavior, per-format return shapes, and the DOCX mode switch keyed on offset/length. This is exactly the added context annotations cannot carry.

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?

Front-loaded and well-organized with headers, bullets, and concrete examples that earn their space. It loses a point for redundancy: the 'absolute paths are the most reliable' point is stated twice in the closing paragraph, and the 'DC: ...' trailer is noise rather than specification.

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 complex 8-parameter tool with no output schema, the description covers return shapes per format (JSON 2D array, base64, markdown, DOCX outline vs raw XML) and the pagination model thoroughly. An agent has everything it needs to invoke it correctly without a return-value 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 coverage is 0%, so the description carries the burden and largely succeeds: offset (including negative tail semantics and the length-ignored interaction), length, isUrl, sheet, and range are all explained with worked examples. It leaves 'origin' and the 'options' object undocumented, so it is not fully compensating for all 8 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 opening line states a specific verb and resource: 'Read contents from files and URLs,' and the format-handling section makes the scope (text, Excel, images, PDF, DOCX) concrete. It does not name the obvious sibling read_multiple_files to distinguish when to pick one over the other, 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?

It gives clear usage context: 'Suitable for reading authorized local files directly without starting a shell command,' plus the constraint that file reads 'only works within allowed directories' and that URLs require isUrl=true. However it never states when to prefer this over read_multiple_files or list_directory, so no explicit alternative routing.

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 the safety profile (readOnlyHint, destructiveHint=false), yet the description adds genuinely useful behavior: partial failure tolerance ('Failed reads for individual files won't stop the entire operation'), image rendering as viewable content with supported types, and directory sandboxing. These go beyond what the annotations provide.

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

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

Purpose and return behavior are front-loaded well, but the path discussion repeats itself ('Absolute paths are the most reliable because...' and later 'Absolute paths are generally the most reliable'), and the closing 'DC:' reference line is meta rather than tool-relevant 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 no output schema, the description usefully explains the return shape (each file's content paired with its path) and image rendering, plus failure and directory constraints. It is nearly complete for a read tool, missing only guidance on choosing it over single-file reads.

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 carry the parameter burden, and it does add real path semantics: automatic normalization regardless of slash direction, tilde caveats, and the reliability argument for absolute paths. It stops short of clarifying array behavior such as ordering, duplicates, or per-path failure reporting.

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 ('Read the contents of multiple files simultaneously'), and the multi-file scope naturally contrasts with the single-file sibling read_file. It is clear, but it never names read_file as the alternative for single-file reads, so differentiation is implied rather than 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?

It gives real constraints ('Only works within allowed directories') and path guidance, but never states when to choose this over read_file or other siblings. Usage is implied by the scope rather than laid out as a selection rule.

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

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

Annotations declare readOnlyHint/destructiveHint/openWorldHint, and the description goes well beyond them: it discloses the fileReadLineLimit-based output protection (default 1000 lines), the status line returned, waiting behavior up to timeout_ms for offset=0, and REPL/completion/timeout detection states. This is exactly the behavioral context the agent needs and cannot get from 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 purpose and offset semantics are front-loaded, and the examples genuinely earn their place given 0% schema coverage. There is some redundancy (the DETECTION STATES list restates the SMART FEATURES points, and some examples overlap), plus a stray 'DC: ...' line, which keeps it from a 5.

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 5-parameter tool with no output schema and 0% schema coverage, the description is largely complete: it explains pagination semantics, return status format, limits, and process states. The only shortfall is the undocumented pid and verbose_timing parameters.

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 carries the burden. It thoroughly documents offset (with a full example table) and length, and briefly mentions timeout_ms under SMART FEATURES, but pid and verbose_timing are entirely undocumented in both the schema and the description, leaving real gaps.

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

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

States a specific verb and resource ('Read output from a running process') and immediately frames it against a known sibling behavior ('file-like pagination support', 'like read_file'). An agent can distinguish it from read_file, interact_with_process, and list_processes without opening any 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?

Gives strong context for the offset modes and, via the detection states, points to interact_with_process when the process is waiting for input. It does not explicitly state when NOT to use this tool or name a full set of alternatives, so it stops short of 5.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description meaningfully extends this by warning that changes affect later file/command behavior and that setting allowedDirectories to [] grants full filesystem access. These are high-value behavioral specifics beyond the annotations, though reversibility and auth requirements are not addressed.

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?

Front-loads the core purpose, then layers the security note, key list, and the critical allowedDirectories warning. Every section carries information, though the DC reference line and repeated framing add minor 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 destructive mutation tool with no output schema, the description covers the key inventory, value types, and the dangerous edge case. It stops short of explaining the origin parameter or whether changes are persistent/reversible, but the essentials for safe invocation are 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 coverage is 0%, so the description carries the burden. It compensates well for the 'key' parameter by listing valid keys with their value types (array, string, number, boolean), but the 'value' parameter's constraints and the 'origin' enum (ui/llm) are left entirely undocumented.

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 ('Set a specific configuration value by key') and enumerates the exact keys that can be set, which lets an agent distinguish it from the sibling get_config. Sibling differentiation is implicit rather than explicit, but the intent 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?

The security note gives some contextual reasoning for isolating configuration changes from untrusted content, which is implied usage guidance. However, it never states when to prefer this tool over get_config or when a change should be avoided, so there are no explicit when/when-not rules or named alternatives.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, and the description adds substantial context beyond that: files written outside mounted volumes are lost on container stop, output is surfaced incrementally for long-running sessions, and verbose_timing exposes exit-reason and timing internals. This is genuinely useful disclosure, though it doesn't state permission/auth requirements.

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

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

The core purpose and examples are front-loaded, which is good, but the definition is heavily bloated with transient runtime content (container ID e404e2a72c27, Docker-detection block, generic Linux package-manager notes) that does not describe the tool's contract and dilutes the signal.

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 an executing, open-world, destructive tool with no output schema, the description covers the process lifecycle well: what starts, how states are detected, when to read output, and how follow-up/interaction works. The main omission is any statement about what the initial call returns or the timeout semantics.

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 five parameters carry no structural documentation and the description must compensate. It fully explains verbose_timing and illustrates command via examples, and notes the default shell (/bin/sh), but leaves origin and timeout_ms entirely undocumented, covering only part of the gap.

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 opening line states a specific verb+resource ("Start a terminal process") and the concrete examples (python3 -i, node -i, wc -l) make the intended use unmistakable. It also names the sibling to use for a running process ("use read_process_output"), which aids differentiation, though it doesn't contrast against interact_with_process or kill_process.

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

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

It enumerates the intended scenarios (shell commands, interactive REPLs, data-processing scripts, long-running work) and gives four concrete invocation examples, which provide strong positive guidance. It stops short of explicit when-not-to-use guidance or direct routing away from sibling tools like interact_with_process or kill_process.

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/non-destructive/closed-world, so the safety bar is covered. The description adds genuine lifecycle context: it starts a background process, returns immediately with a session ID, results flow through a sibling, and it can be cancelled. Path normalization/tilde-resolution caveats are also disclosed. It does not state timeout or maxResults behavior, keeping it below 5.

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 purpose is front-loaded, but the body is heavily redundant: 'DECISION EXAMPLES', 'COMPREHENSIVE SEARCH EXAMPLES', and the closing paragraphs repeat the same file/content selection rules several times. A large fraction of the text does not earn its place against what a shorter guide would convey.

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 session-based streaming tool with no output schema, the description adequately explains the async lifecycle, where results appear, and how to cancel. It is complete enough to invoke correctly; only the unmentioned tuning parameters (timeout_ms, maxResults) leave minor gaps.

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

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

Schema coverage is 0%, so the description carries the full burden, and it meaningfully documents the core params: pattern, searchType, literalSearch, filePattern, ignoreCase, earlyTermination, plus path reliability. However several params (maxResults, timeout_ms, contextLines, includeHidden, origin) receive no explanation, leaving real gaps.

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+resource (start a streaming search returning results progressively), and explicitly names the sibling tools that continue/cancel it (get_more_search_results, stop_search). An agent can tell it apart from list_searches and other siblings without opening any 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?

Provides an exhaustive when-to-use guide: explicit rules for choosing searchType='files' vs 'content', an ambiguity protocol (run both), and worked decision examples. This is far beyond typical routing guidance.

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

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

Annotations already declare destructiveHint=false; the description goes beyond them by disclosing that shutdown is 'graceful' and that the search remains readable until cleanup after 5 minutes. That post-condition is exactly the kind of context annotations cannot carry. It does not describe error behavior if the sessionId is invalid, keeping it short of a 5.

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?

Purpose is front-loaded in the first sentence and the operative guidance follows immediately. The closing boilerplate about referring to the tool as 'DC: ...' consumes space without helping tool selection, a minor waste.

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

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

For a one-parameter action tool with no output schema, the definition covers purpose, when to invoke it, and what happens to the search afterward. The only real gap is that the sessionId parameter is left entirely to 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% for the single sessionId parameter, and the description never mentions it or explains which session it targets. The name is largely self-explanatory and the context implies it acts on an active search, so this is adequate rather than compensating for the coverage gap.

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 ('Stop an active search') and explicitly distinguishes itself from the closest sibling by noting it is 'Similar to force_terminate for terminal processes.' An agent can tell it apart from start_search, list_searches, and force_terminate without opening any 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?

Gives a clear trigger condition: 'Use this when you've found what you need or if a search is taking too long,' and names force_terminate as the analogous tool for terminal processes. It stops short of an explicit when-not (e.g., when to prefer letting a search finish or how it differs from kill_process), so it is strong but not exhaustive.

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=false, destructiveHint=true, and openWorldHint=false, so the mutation/overwrite risk is covered. The description adds genuinely useful context: performance notes for files over 50 lines, the allowed-directory constraint, path normalization behavior, and per-extension format rules. It never explicitly states that mode='rewrite' destroys prior contents, which is the one behavioral gap.

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

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

The header-based structure is scannable and the purpose is front-loaded, but it wastes space: the absolute-path advice is stated twice in near-identical sentences, and the trailing 'DC: ...' / 'use Desktop Commander to ...' marketing line adds nothing to tool selection.

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 mutation tool with no output schema, the description covers formats, chunking strategy, path resolution, and the sandboxing constraint, which is close to what an agent needs. It leaves return-value expectations and failure behavior unstated, but annotations already carry the destructive safety profile.

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 only partly does. It explains mode well (rewrite vs append with chunk continuation), content format for text and Excel, and path semantics (absolute vs relative vs tilde, slash normalization) — but the 'origin' enum parameter is never mentioned anywhere, leaving one of four parameters undocumented in both schema and description.

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+resource ('Write or append to file contents') and immediately routes away from siblings: PDF goes to write_pdf, existing DOCX editing goes to edit_block. An agent can distinguish this from read_file, edit_block, and write_pdf without opening any 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?

Names alternatives with the condition that selects them (write_pdf for PDFs, edit_block for existing DOCX) and gives concrete guidance on chunked writes with mode='rewrite' followed by mode='append' and a 25-30 line chunk recommendation. It lacks any general when-not-to-use guidance (e.g. binary files, read-only directories), so it stops short of a 5.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, openWorldHint=false. The description adds meaningful context beyond them: modifications preserve the original PDF and require a distinct output filename, the result returns both original and output paths, and access is restricted to allowed directories. This is solid behavioral disclosure, though it doesn't clarify overwrite behavior at outputPath.

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 sectioning (MODES, OPERATIONS, PAGE BREAKS, ADVANCED STYLING) is well organized and front-loaded. However it is bloated: the final paragraph restates 'Absolute paths are the most reliable' twice, and the trailing 'DC: ...' boilerplate adds no invocation value. Wasteful repetition holds it to a 3.

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 no output schema and a nested anyOf parameter, the description supplies the essential operational detail: mode selection, both content shapes, operation syntax, page-break mechanism, and file path requirements. Only the unexplained 'options' parameter and overwrite semantics leave minor gaps.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: 'content' is fully explained (markdown string for create, operations array for modify), 'path' vs 'outputPath' roles are spelled out, and the insert/delete operation shapes are documented with examples. The 'options' and 'pdfOptions' parameters remain entirely unexplained, keeping this from a 5.

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+resource ('Create a new PDF file or modify an existing one') and reinforces it with 'Dedicated PDF creation and modification tool.' This is clearly distinguished from generic file tools in concept, but it never explicitly names or contrasts with the sibling write_file, so it earns a 4 rather than a 5.

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

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

It clearly separates the two modes (CREATE NEW vs MODIFY EXISTING) and gives the condition selecting each, plus concrete invocation examples. What's missing is any explicit when-not guidance or reference to alternative tools (e.g., write_file for non-PDF output), so it stops short of the 5 level.

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