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

Annotations already declare the operation is not read-only, is idempotent, and is not destructive. The description adds no behavioral context beyond the obvious act of installing packages, such as requiring privileges, modifying system state, or network/cache implications.

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

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

The description is short and the core purpose is front-loaded. The Args/Returns block adds some structure but is largely redundant with the schema, so it is concise rather than maximally informative.

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 provides a minimally viable summary: what it does and what it returns. However, it omits useful context such as remote host prerequisites, administrative requirements, and how the chosen response_format affects the output.

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 only lists parameter names (packages, host, response_format) without adding semantic detail. Although the nested schema contains rich descriptions, the top-level schema coverage is 0%, and the description does not compensate by explaining defaults, constraints, or allowed 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 states a specific action and resource: installing one or more packages with APT. This clearly differentiates it from siblings like apt_remove, apt_update, apt_search, and snap_install.

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

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

No explicit guidance is given about when to choose this tool over alternatives such as apt_update, apt_upgrade, apt_remove, or snap_install. The description only implies usage by saying 'install one or more packages with APT'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by explicitly stating the tool does not execute an upgrade and by describing the return content as package name, current -> new version. No contradiction with annotations exists.

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

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

The description is compact and well-structured: a one-sentence purpose statement with the non-destructive guarantee front-loaded, followed by concise Args and Returns sections. Every sentence earns its place with no filler or repetition.

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

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

For a simple read-only listing tool, the description covers the core behavior, return format, and non-mutating nature, while annotations cover safety and the schema covers host and response_format details. It falls slightly short of a 5 because it does not explicitly connect to sibling apt_update/apt_upgrade tools or mention how the local vs. remote host distinction might affect invocation.

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

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

The description only lists parameter names (host, response_format) without explaining their meaning or usage. The input schema does contain descriptions for host and response_format, but the context signal reports 0% schema description coverage, so the description does not compensate for that gap and adds almost no semantic value beyond the schema.

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

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

The description says 'Lista arrol, mely csomagok frissithetok most' (lists which packages are upgradable now), which is a specific verb+resource+scope. It also explicitly states 'nem futtat frissitest' (does not run the upgrade), which distinguishes it from the sibling apt_upgrade, though it does not name that sibling or other alternatives.

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

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

The phrase 'nem futtat frissitest' gives clear context that this is a check-only operation, implying the user should use it to preview upgrades before running apt_upgrade. However, it does not explicitly state when to choose this over apt_update, apt_search, or apt_show, nor does it list exclusions or alternative tool names.

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

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

The annotations already mark the tool as destructive and not read-only; the description adds useful behavioral context by warning 'RENDSZERSZINTU valtoztatas - megerositest ker' (system-level change - asks for confirmation). This goes beyond the annotations and helps an agent understand the operational impact.

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

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

The description is short, front-loaded with the critical system-level warning, and uses clear Args/Returns sections. Every sentence contributes meaningful information with no redundant filler.

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

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

For a destructive system-level operation, the description conveys the essential confirmation behavior and scope, and the schema covers parameter details. However, it lacks explicit routing guidance versus sibling tools and does not mention potential side effects such as dependency or configuration changes, making it adequate but not fully 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 reported as 0%, so the description should compensate by explaining the parameters. It only lists 'packages (lista), host, response_format' without clarifying host selection, response format options, or package constraints. The nested schema does contain this information, but the tool description itself adds little semantic value.

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 'Egy vagy tobb csomag eltavolitasa' (removal of one or more packages), giving a specific verb and resource. The tool name and title further disambiguate it from installation-related siblings like apt_install and snap_remove.

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 removing packages, but it provides no explicit guidance on when to choose it over alternatives such as apt_install, apt_upgrade, or snap_remove. There are no stated prerequisites, exclusions, or use-case conditions beyond the purpose itself.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that it searches packages and returns a result list, but it does not disclose additional behavior such as remote-host execution implications or output format details beyond the basic return type.

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 purpose is front-loaded in a single clear sentence, followed by a compact Args/Returns section. It is concise and readable, though the Args/Returns block is somewhat redundant with the structured schema.

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

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

For a simple read-only search tool, the description plus annotations and schema are largely sufficient: it conveys the search behavior, parameters, and return type. Minor gaps remain about the exact contents or formatting of the result list, but they do not seriously impede correct usage.

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 merely lists the parameter names query, host, and response_format without explaining them. However, the nested schema definitions provide meaningful descriptions for each parameter, so the schema already covers parameter semantics; the description adds little value on top.

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

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

The description clearly states the tool performs a package search by name/description based on 'apt-cache search', giving a specific verb and resource. It is easy to tell this is a read-only search tool, though it does not explicitly differentiate itself from sibling tools like apt_show or apt_list_upgradable.

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 use this tool versus alternatives such as apt_show, apt_install, or apt_list_upgradable. The description implies a search use case but does not state exclusions or recommend sibling 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=true, idempotentHint=true, and destructiveHint=false. The description adds a little behavioral context by identifying `apt-cache show` and saying the result is a string, but it does not discuss edge cases like unknown packages or host connection failures. There is no contradiction with the annotations.

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

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

The description is compact and well-structured into purpose, args, and returns sections. It front-loads the core operation and contains no redundant filler, so every 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 simple read-only package metadata query, the description plus the nested schema and safety annotations are largely sufficient for correct invocation. The main gap is the lack of explicit guidance about choosing this tool over package-search or package-management siblings, but nothing critical is missing for calling the 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 description lists the parameter names `packages`, `host`, and `response_format` but does not add new semantics for them. The nested schema actually provides detailed descriptions for all three fields, so the schema does most of the work and the description is not misleading, just minimal.

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

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

The description clearly states the action: providing detailed information about one or more packages, and it names the underlying `apt-cache show` command. This makes the tool's purpose distinct from sibling tools like apt_search, apt_install, or apt_remove.

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 use when package metadata is needed, but it does not explicitly state when to use it versus apt_search, apt_list_upgradable, or other package-related tools. The usage context must be inferred from the command reference and tool name rather than being directly explained.

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

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

Annotations already convey non-destructive and idempotent behavior. The description adds the useful detail that nothing is installed or upgraded and that the command output is returned, but it does not mention side effects like writing local package lists or needing network/root permissions.

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

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

The description is compact, front-loaded with the core action, and every sentence adds information about scope or return value (e.g., 'Nem telepit es nem frissit semmit'). No filler.

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

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

For a simple command-style tool, the description covers the operation, non-effects, and return type. It does not discuss when to choose an alternative APT tool, and it relies on the schema for parameter details, but that is acceptable given the tool's simplicity.

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 only lists the parameter names ('host, response_format') and does not explain their meaning or defaults. With reported schema coverage at 0%, the description should compensate for the schema gap, but it does not.

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 operation (package list refresh) and anchors it to 'apt-get update', then explicitly distinguishes it from installing or upgrading packages. This separates it from sibling tools like apt_upgrade and apt_install without requiring schema inspection.

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

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

It clearly states the scope ('apt-get update', no install/upgrade), which tells the agent when not to use it. It does not explicitly point to alternative sibling tools (e.g., apt_upgrade for actual upgrades), but the negative scope is strong enough to prevent confusion.

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 clearly warns 'RENDSZERSZINTU valtoztatas - megerositest ker' (system-level change - confirmation requested), adding a meaningful behavioral trait beyond the annotations. It also discloses that the return string includes the upgrade output and final state verification. This is consistent with destructiveHint=true and readOnlyHint=false, with no contradiction.

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 well-structured and front-loaded: the main action and system-level warning appear first, followed by prerequisite recommendations and a short Args/Returns section. It is concise with no unnecessary filler, though the Args block is somewhat redundant with the schema.

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 system-level tool, the description provides essential context: the action, the confirmation requirement, recommended preconditions, and the return value. It does not elaborate on remote host behavior or failure modes, but the schema covers host semantics and an output schema is present, so the description is adequately 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?

With the context signal showing 0% schema description coverage, the description was expected to compensate, but the Args section only lists field names and types: 'full (bool), host, response_format.' It does not explain what these parameters do or their implications, leaving the agent to discover that meaning in the nested schema definitions. Some value is added by mapping the fields, but semantics are almost entirely absent from the 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?

The description states a specific verb and resource: 'A telepitett csomagok frissitese' (upgrade installed packages). It implicitly distinguishes itself from apt_update/apt_list_upgradable by recommending those as prior steps, and from apt_install/apt_remove by focusing on upgrading existing packages. However, it does not explicitly name a sibling or draw a direct contrast, leaving some room for interpretation.

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

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

The description explicitly recommends running 'apt_update' and 'apt_list_upgradable' before this tool so the agent can inspect what will change, giving clear sequential context. It does not provide explicit when-not-to-use conditions or mention alternatives like apt_install or apt_remove, but the suggested prerequisite workflow is strong enough 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 and destructiveHint=false, so the safety profile is covered. The description adds that the tool returns aggregated/per-core percentages and load average, which is useful output context. However, it does not disclose any behavioral traits such as remote host requirements beyond the schema, rate limits, or whether it may block or take time to execute.

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

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

The description is short and well-structured with clear Args and Returns sections. The main capability is front-loaded in the first clause. No superfluous text or repetition of annotation data appears, though the Hungarian phrasing is slightly compact.

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

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

For a simple read-only monitoring tool, the description covers the core purpose, parameter names, and return type. The schema provides details for host and response_format, and annotations cover safety. Missing is any mention of output format specifics or when to prefer this over related monitoring tools, but that gap is minor for this low-complexity 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 description merely lists 'host, response_format' under Args without explaining their meaning. Schema description coverage is 0% at the top level, and while the nested schema contains descriptions, the tool description itself does not compensate for the wrapper parameter being opaque. It adds minimal value over the raw parameter names.

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

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

The description states the resource (CPU) and the specific metrics returned: aggregated and per-core percentages, and load average. This clearly differentiates it from sibling tools like memory_usage or disk_usage. It lacks an explicit verb like 'list' or 'get', but the Returns line makes the retrieval intent obvious.

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

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

No guidance is given on when to choose this tool over alternatives. The description does not mention that memory_usage, disk_usage, or system_status should be used for other resource metrics, nor does it give exclusions or conditions. Usage context is only implied by the tool name and resource focus.

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 explicitly adds 'MINDIG megerositest ker' (always asks for confirmation), which is behavioral context not present in the annotations. Annotations already indicate destructiveHint=true and idempotentHint=true, and the description aligns with them without contradiction.

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

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

The description is short and front-loaded with the main purpose, followed by minimal Args/Returns sections. It has no unnecessary padding, though the Args line is slightly incomplete by not mentioning response_format.

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

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

Given that destructiveHint, idempotentHint, and an output schema are present, the description is largely complete for a simple deletion tool. It adds the key confirmation behavior and correctly describes the return as confirmation, while heavier parameter details are left 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?

The Args section lists only 'path, recursive, host' inside params but provides no semantics, types, defaults, or constraints, and omits response_format entirely. Schema description coverage is reported as 0%, so the description does not compensate for the missing parameter guidance, even though the nested JSON schema itself has some field descriptions.

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

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

The description clearly states the operation: 'Fajl vagy konyvtar torlese' (delete file or directory). This is a specific verb plus resource and distinguishes delete_path from siblings like apt_remove, snap_remove, and host_remove, which operate on different resource types.

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

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

No guidance is given about when to use this tool versus alternatives, nor are exclusions or prerequisites mentioned. The description only says what the tool does, not how to choose it over other path-related tools such as move_path or write_file.

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 and destructiveHint=false, so the safety profile is covered. The description adds the Tesseract OCR detail and the dual screen/file source, but it does not mention that an empty image_path triggers a screenshot; that behavior appears only in the 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 description is compact and front-loaded with its core purpose, followed by a minimal Args/Returns stub. It is appropriately sized for a simple tool, though it sacrifices useful guidance for brevity.

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

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

For a simple read-only OCR tool, the description conveys the main operation and return type. However, it lacks routing guidance and leaves the agent to discover key behavior like the screenshot fallback from the schema, so it is only minimally 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?

The description merely lists parameter names ('image_path, lang') without explaining their meaning, defaults, or the null-image_path behavior. Context reports 0% schema description coverage at the top level, and the description does not compensate for that 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 description states a clear action and resource: extract text from the screen or an image file using Tesseract OCR. It is unambiguous about what the tool does, but it does not explicitly distinguish itself from sibling tools like `screenshot` or `read_file`.

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

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

The description gives no guidance about when to use this tool versus alternatives, and it names no exclusions or conditions. An agent cannot tell from the description whether to prefer `desktop_ocr` over `screenshot` for screen content or `read_file` for image files.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value beyond this by specifying the exact output breakdown (size / used / free / percentage) and the df -h equivalence, giving a clear behavioral model without contradicting the annotations.

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

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

The description is concise and well-structured: a one-line purpose with a familiar command equivalence, followed by compact Args and Returns sections. Every sentence carries useful information and there is no redundant text.

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

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

For a simple read-only monitoring tool, the description plus annotations and schema cover the essential information: what it returns, the parameter meanings, and the non-destructive/idempotent nature. It could be more complete with explicit alternatives or error conditions, but nothing critical is missing for basic invocation.

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

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

The description merely lists 'host, response_format' without adding semantic detail beyond the input schema. However, the schema's nested HostOnlyInput definition already documents both parameters well, including host default behavior and response_format meaning, so no critical parameter information is missing.

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

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

The description clearly identifies the resource as 'csatolt fájlrendszerek kihasználtsága' (mounted filesystem usage) and anchors it with the well-known 'df -h ekvivalens' equivalence. This immediately distinguishes it from sibling tools like cpu_usage and memory_usage.

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 'df -h equivalent' statement gives implied context for when to call the tool, but there is no explicit when-to-use guidance, exclusion criteria, or mention of an alternative tool. An agent can infer usage, but the description does not actively route between 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 mark the tool as destructive. The description adds useful behavioral context: matching is literal, the target file must already exist, and the return value reports how many replacements occurred. It does not disclose failure behavior when old_string is not found or whether the file is modified in place without backup.

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

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

The description is compact and front-loaded, with a clear one-sentence summary followed by Args/Returns blocks. The Args list omits response_format, making it slightly incomplete, but overall it is efficient and free of filler.

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

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

Given the rich schema descriptions and destructiveHint annotation, the description is mostly sufficient: it explains the core operation, the literal-match constraint, and the return contract. The main gaps are no-match behavior and in-place/backup semantics, which are not covered elsewhere.

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 only lists parameter names and does not explain their meaning. The input schema itself provides detailed descriptions for path, old_string, new_string, count, host, and response_format, so the description adds little semantic value beyond the schema.

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

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

The description states a specific operation: exact text replacement in an existing file, and explicitly adds 'not regex'. This distinguishes it from write_file-style whole-file overwrites and from any regex-based substitution tool.

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 guidance is implied rather than explicit: 'existing file' suggests it is not for creating files, and 'not regex' rules out regex substitutions. However, no alternative tool is named and there is no clear when-to-use vs. when-not-to-use 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, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds a list of returned metadata fields but no further behavioral context such as remote-host resolution, missing-file behavior, or response_format effects. It does not contradict the annotations.

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

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

The description is compact: one lead sentence followed by a minimal Args/Returns block. It contains no filler or repetition of annotations, though the Returns line adds little information.

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

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

For a simple metadata read, the annotations and schema provide the core safety and parameter details. However, the description omits when to choose this tool over list_files/read_file and does not mention failure or remote-host edge cases, so completeness is adequate but not strong.

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 merely repeats the parameter names path, host, and response_format without adding meaning about requiredness, types, defaults, or host semantics. With schema description coverage reported at 0%, the description should compensate for missing parameter documentation, but it does not.

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 that the tool returns file/directory metadata (size, type, permissions, owner, timestamps), which distinguishes it from sibling tools like list_files or read_file. It lacks an explicit verb such as 'get', but the Returns clause makes the read intent 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?

No guidance is given on when to use file_info instead of list_files or read_file, nor is any alternative mentioned. The description only says what the tool returns, leaving selection entirely to inference.

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

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

The description adds behavioral context beyond annotations: it persists data to a config file, returns a secret-free record, and explains the environment-variable password mechanism. Annotations already cover idempotency and non-destructiveness, so no contradiction exists.

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

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

The description is concise and well-structured: a short purpose statement, a key warning about passwords, a compact argument list, and a return value description. Every section adds value and is front-loaded with the most important usage constraint.

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 persistent configuration mutation with one nested parameter object, the description covers purpose, persistence, secret handling, and return type. The output schema is present, and annotations cover idempotency and destructiveness. Nothing essential is missing 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 for the top-level parameter is 0%, but the description compensates by enumerating all fields in HostAddInput. It adds critical semantic meaning, especially that password_env and sudo_password_env should contain environment variable names, not passwords. The individual property descriptions in the schema provide additional detail.

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: adding a new remote host to the configuration and saving it to the config file. This clearly distinguishes host_add from sibling tools like host_remove, host_list, host_test, and host_run, which serve different purposes.

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

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

The description clearly indicates when to use the tool: when adding a new remote machine to the config. It also gives important usage guidance about not putting the actual password in password_env/sudo_password_env, only the name of an environment variable. It does not explicitly discuss alternatives or exclusions, but the context 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 notes that the private key stays local, that the public key must be manually installed, and that the return value contains both the private-key path and the public-key line. This goes beyond the annotations, which only set readOnlyHint/idempotentHint/destructiveHint to false, and clarifies the tool's output and side-effect profile.

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

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

The description is concise and well-organized: a one-line purpose, a short workflow note referencing host_add, and labeled Args/Returns sections. Every sentence carries operational information, and the structure makes it easy for an agent to parse.

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 key-generation tool with one object parameter, the description covers the generated output, the required follow-up steps, and the return value. It does not mention overwrite behavior or file permissions, but these are minor given the annotations and the focused scope of the 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 description only restates the parameter names ('name, comment') without explaining their meaning or format. The schema's nested descriptions are the sole source of parameter semantics, and with schema description coverage reported at 0%, the description fails to compensate for the lack of accessible parameter 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 opens with a clear statement: 'Generate a new ed25519 SSH key pair in the server's key directory.' This is a specific action on a specific resource and none of the sibling tools (host_add, host_list, host_test, etc.) overlap with key generation.

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 concrete usage context: after generating, copy the public key to the remote authorized_keys file and then supply the private key path to host_add via 'key_path'. This effectively tells the agent when and how to use the tool in the host-management workflow, though it does not explicitly list exclusionary conditions or 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 readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds the useful 'titkok nelkul' (no secrets) caveat, but does not disclose additional behavioral traits such as configuration source or failure behavior; with strong annotations this is acceptable but not exceptional.

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 first front-loads the tool's scope and the secret-handling caveat, and the second specifies the per-host fields. Every 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 zero-parameter, read-only listing tool, the description is complete: it states what is returned, which fields are included, and that secrets are excluded. Annotations cover the safety aspects and the schema covers the empty argument, so no critical information is missing.

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

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

The only parameter is an EmptyInput wrapper with no properties, so there is effectively no parameter semantic to document. The input schema itself makes clear that the caller must pass an empty object, so the description need not compensate for a 0% schema-description coverage gap in this case.

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

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

The description states the resource as 'configured remote machines' and the exclusion of secrets, then enumerates the returned per-host fields (name, hostname, user, port, key/password-env). This clearly identifies a read-only host inventory and distinguishes it from mutating host_* siblings, though it is phrased as a noun phrase rather than an explicit command verb.

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 use case: retrieving configured remote hosts, and the 'without secrets' caveat signals it is not for obtaining credentials. However, it does not explicitly name alternatives or state when not to use it compared with host_add, host_remove, host_test, or host_run, so usage guidance is only implicit.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description aligns by stating the host is removed from configuration. It adds that the return value is a confirmation string, but does not disclose details like irreversibility, permission requirements, or effects on related data. With destructive annotation present, this is adequate but not enriched.

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

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

The description is short and front-loaded with the main action. The Args and Returns sections are minimal but functional, and there is no filler. It could be slightly more explicit about the parameter semantics, but overall well-structured.

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

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

For a one-parameter destructive operation, the description plus annotations (destructive, idempotent) and output schema give an agent enough to call it correctly. It names the input, the effect, and the return type. It doesn't discuss failure modes, but that level of completeness is not essential here.

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 description only repeats the argument name ('name') without adding meaning. Although the nested schema property has a description, the reported schema description coverage is 0%, so the description should compensate; it does not explain what names are valid or how the name maps to a configured host.

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 ('torlese' = deletion) and resource ('tavoli gep' / remote machine from configuration), which clearly distinguishes it from siblings like host_add, host_list, and host_test. The action is unambiguous and the resource scope is defined.

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

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

No explicit when-to-use or alternative conditions are provided. However, the deletion semantics imply it is for removing a configured remote host, and the sibling set includes host_add for the opposite operation. No prerequisites, exclusions, or when-not-to-use guidance are given.

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?

A leírás a kockázati kaput ismerteti, vagyis hogy a magas kockázatú műveletek (rm -rf, reboot, tűzfal) megerősítést kérnek; ez túlmutat a destructiveHint annotáción. Emellett a visszatérési érték str-ként való deklarálása is hasznos. Az annotációkkal nincs ellentmondás.

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?

Az első két mondat tömör és jól elöl helyezkedik el, a kockázati kapu azonnal látható. Az Args szakasz viszont feleslegesen ismétli a sémát, és hibás kötelezőségi jelölést tartalmaz, így nem minden rész érdemli ki a helyét.

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?

A tool alapfunkciója és a kockázati kapu viselkedése világos, a séma részletes paraméterleírásokat ad. Ugyanakkor a leírás nem említi a lokális futtatás lehetőségét, nem utal a host_add előfeltételre, és a kötelező paraméterekről adott kép hibás, így a teljes kép nem teljes.

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?

A leírás csak felsorolja a paramétereket, és tévesen állítja, hogy a 'host' kötelező, miközben a séma szerint a 'command' az egyetlen kötelező mező, a host pedig alapértelmezetten a lokális gépre mutat. A 0%-os séma-lefedettség miatt a leírásnak kompenzálnia kellene, de nem ad hozzá magyarázatot, sőt félrevezető információt tartalmaz.

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?

A leírás egyértelműen megnevezi a tevékenységet: egyszeri shell parancs futtatása konfigurált távoli gépen. Ez megkülönbözteti az interaktív terminál eszközöktől és a helyi shell futtatástól, így az ügynök pontosan tudja, mit várhat.

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?

A 'KONFIGURALT tavoli gepen' kitétel világos kontextust ad: a tool olyan gazdagépekre vonatkozik, amelyek már szerepelnek a konfigurációban. Név szerint nem jelöl alternatívát, és nem zárja ki a lokális futtatást, de a sémában a host paraméter leírása ezt kiegészíti.

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, idempotentHint, destructiveHint), the description discloses concrete behavior: it performs an SSH login and runs specific diagnostic commands. This is useful context. It could additionally mention failure modes like unreachable hosts or auth errors, but the safety profile is already covered by annotations.

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

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

The description is compact and well-structured: purpose first, then Args and Returns. Every sentence contributes useful information, and the main action is front-loaded.

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

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

For a simple single-parameter tool with rich annotations and an output schema, the description is largely complete: it states the action, the commands executed, and the return value. Minor gaps remain around failure behavior and host configuration assumptions, but these are partly addressed by the schema's parameter description.

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's Args section only repeats the parameter name ('name') without adding meaning. The input schema does contain a description, but the reported schema description coverage is 0%, and the tool description itself fails to compensate by explaining that the name must refer to a configured host.

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

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

The description states a specific action and resource: testing an SSH connection to a machine by logging in and running 'id' and 'uname -a'. This clearly sets it apart from siblings like host_run or shell_run, which execute commands, and from read-only system inspection tools.

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

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

The description explains what the tool does but gives no guidance on when to choose it over alternatives such as host_run or shell_run. There is no mention of prerequisites, when not to use it, or that it is intended for connectivity verification before other operations.

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 that this uses xdotool key and returns a confirmation string, but it does not disclose important behavioral traits such as that key events go to the currently focused window, that repeated presses can trigger multiple actions, or that side effects depend on the active application. With annotations providing little safety context, the description carries more responsibility than it fulfills.

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

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

The description is short and front-loads the purpose with useful examples before the Args/Returns block. The Args line is somewhat redundant with the schema, but overall the structure is compact and easy to scan.

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 only two parameters, the description plus schema is mostly sufficient to make a correct call. However, it lacks context about focus-dependent behavior, potential side effects of pressing keys, and how to choose between this and sibling tools like keyboard_type or terminal_write.

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 merely lists 'keys, repeat' without explaining repeat semantics, constraints, or requiredness. The schema contains the actual parameter descriptions and constraints, and because schema description coverage is reported as low, the description does not compensate by adding meaning beyond the schema.

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

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

The description clearly states the action: pressing a key or key combination using xdotool, with concrete examples like 'ctrl+alt+t' and 'Return'. It is distinct from siblings like keyboard_type because it emphasizes key combinations/actions rather than text entry, though it does not explicitly name a sibling.

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

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

The examples imply when to use the tool: when a key or key combination needs to be pressed. However, there is no explicit guidance about when not to use it or which sibling tool to prefer for typing text, so usage context is only implied rather than fully 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 indicate readOnlyHint=false and destructiveHint=false, so the tool is known to perform a write/input action but not destructive. The description adds useful behavioral context: it uses xdotool and types into the currently focused window, implying low-level OS input simulation. It also clarifies the delay_ms parameter as inter-character delay, which is behavioral context not in the schema. However, it doesn't mention side effects like active window focus requirement or potential send failures.

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

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

The description is short and front-loaded with the main verb phrase. It includes an Args/Returns structure that is somewhat mechanical and redundant with the schema. The sentence 'Returns: str: Megerosites.' is thin and doesn't explain what the confirmation contains, but it is concise and not bloated.

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

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

The tool has 1 required parameter, no output schema details, and no nested objects, so complexity is moderate. The description covers the core action and names the parameters, but with 0% schema coverage and a vague return description, an agent might not know how to properly use delay_ms or interpret the confirmation string. There is also no guidance on keyboard focus prerequisites. This is adequate but not 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%, meaning neither parameter (text, delay_ms) is described in the schema. The description only mentions 'text, delay_ms' as a list, without explaining that text is the string to type or that delay_ms is the delay between characters. This is a significant gap because the description adds almost no semantic meaning beyond the parameter names.

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: typing text into the currently focused window via xdotool. It distinguishes itself clearly from siblings like keyboard_press (which sends individual key presses) by emphasizing 'Szoveg begepelese' (typing text) into the focused window. However, it lacks an explicit contrast with the sibling keyboard_press, so it is clear but not fully differentiated.

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: type text into the focused window. It does not explicitly state when to use this tool versus keyboard_press or other input tools, nor does it mention prerequisites like focusing a window first. The context is clear enough for basic use but lacks explicit alternative selection 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?

Beyond annotations, the description discloses that the launch is background/detached, that gtk-launch is tried first with a direct command fallback, and that the return is a confirmation string possibly including the PID. This is meaningful behavioral context and does not contradict 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 tightly organized: a one-sentence summary, the launch strategy, and then Args/Returns. Every sentence adds relevant information with no filler.

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

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

For a launch tool with annotations and an output schema, the description is nearly complete: it covers the launch mode, the fallback mechanism, and the return value. It could be slightly stronger by explicitly stating that this tool is for detached launches only and that interactive use belongs to terminal_open or shell_run.

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 only lists the parameter names 'application' and 'arguments' without explaining their meaning or usage. Schema description coverage is reported as 0%, so the description should compensate, but it does not clarify accepted formats, argument behavior, or required fields.

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 a specific action: launch a graphical (or any) application in the background, detached. It also describes the mechanism (gtk-launch with .desktop name, falling back to direct command), which distinguishes it from sibling tools like terminal_open or shell_run.

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

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

The intended use is implied: use this when you want to launch an application detached in the background. However, there is no explicit guidance about when NOT to use it or which sibling to prefer for interactive/foreground command execution.

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 return-type note ('Returns: str: A konyvtar bejegyzesei') but otherwise does not disclose behavioral traits beyond what the annotations already provide (readOnlyHint, idempotentHint, destructiveHint). It does not contradict the annotations and is minimally adequate for a read-only listing tool.

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

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

The description is concise and front-loaded with the purpose. However, the Args section merely repeats parameter names already visible in the schema, and the overall structure is sparse rather than deliberately minimal.

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 enough for a simple read-only file listing tool: it states the purpose, the return type, and the parameter names. It lacks richer context such as output format behavior or when to use host/response_format, but the schema covers these details partially.

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 lists parameter names (path, all, long, host, response_format) but provides no semantic explanation. The input schema actually documents each parameter in detail, but based on the reported 0% schema description coverage, the description was expected to compensate and does not.

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

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

The description clearly states the tool lists directory contents ('Egy konyvtar tartalmanak listazasa'), using a specific verb and resource. It does not explicitly distinguish itself from sibling tools like read_file or file_info, but the directory-scoped phrasing makes the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or sibling tool exclusions, leaving the agent to infer usage from the name and parameter list 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 and destructiveHint=false, so the safety profile is covered. The description adds the behavioral detail that the tool wraps journalctl and can read a concrete file, and states its return is the requested log lines, which is useful but does not go deeper into pagination, errors, or remote-host behavior. No contradiction with annotations.

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

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

The description is compact: a single front-loaded purpose sentence followed by orderly Args and Returns sections. There is no filler or repetition, and the essential information appears first.

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 logging tool, the description plus the detailed schema and safety annotations covers the main call path: source selection (unit vs path), filters, output format, and return type. It does not address sibling-tool selection or failure modes, but those are secondary for this simple, read-only 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 description only enumerates parameter names (`unit`, `path`, `lines`, `since`, `grep`, `host`, `response_format`) without explaining them. The input schema itself provides rich per-property descriptions, so the schema carries the semantics burden; the description adds little beyond the field list.

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 'Rendszernaplok olvasasa' (reading system logs) and names concrete mechanisms: journalctl by unit or a specific log file. This clearly identifies the operation and resource, distinguishing it from siblings like `system_info` or `service_status`, though it does not explicitly contrast 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?

Usage is implied by the purpose statement and the 'unit OR path' hint, but the description never states when to prefer this tool over alternatives such as `service_status` or `process_list`, nor does it mention exclusions or prerequisites. There is enough context to infer the use case, but no explicit 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 readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds the valuable behavior that parent directories are created ('es szuloi') and notes the return is a confirmation string. No contradiction with annotations.

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

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

The definition is compact and front-loaded: one line for purpose, one for parameters, one for returns. There is no filler or redundant exposition.

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

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

For a simple one-required-parameter tool, the description plus annotations and schema cover the core action, parent-directory behavior, and confirmation result. The missing usage-vs-alternatives context is a gap, but it is separately captured under usage guidelines.

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 Args line simply names 'path, host' and omits response_format entirely; it provides no meaning beyond the parameter names. With schema description coverage reported at 0%, the description should have compensated but does not.

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 the specific verb and resource: 'Konyvtar (es szuloi) letrehozasa' (create directory and parents). This states exactly what the tool does and distinguishes it from sibling file operations like list_files, write_file, and delete_path.

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 when-to-use guidance, no exclusions, and no mention of alternatives. The description only restates the action, so an agent must infer when to choose make_dir over file/host 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?

The annotations already communicate readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that the tool reports RAM/swap usage with specific categories, but it does not disclose units, output formatting beyond the schema, or host-resolution behavior. No contradiction with annotations.

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

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

The description is short and front-loaded with the operational purpose, followed by a compact Args/Returns structure. It is appropriately sized for a simple read-only tool, though the Args line is somewhat redundant with the schema.

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

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

For a low-complexity, read-only memory query, the description, schema, and annotations together cover the essential behaviors: resource, metric categories, host selection, and response format. The main missing piece is usage guidance relative to sibling tools, which is captured separately.

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 Args line only lists the parameter names host and response_format without explaining their meaning. The nested schema definitions provide the actual semantics such as local-host fallback and markdown/json values, so the description's contribution is minimal but not misleading.

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 explicitly names the resource (RAM and swap), the exact metric categories (total/used/free/available/cache), and states the return type (memory indicators). This is specific enough to distinguish it from siblings like cpu_usage, disk_usage, and system_info.

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 alternatives such as system_info or process_list. The schema mentions remote-host prerequisites, but the description itself does not state when to select this tool or when to use another one.

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 are all false and therefore convey little behavioral detail, so the description carries the burden. It adds useful context by saying coordinates are optional and that the click happens at the current mouse position, and it states that a confirmation string is returned. However, it does not disclose side effects such as focus changes or window activation, nor whether the pointer is moved before clicking.

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

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

The description is compact and front-loaded: one sentence for the core behavior, a minimal Args line, and a Returns line. Every sentence earns its place and there is no repetition of annotations or schema noise.

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

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

For a low-complexity mouse action with an output schema and nested parameter descriptions, the description is largely sufficient: it states the action, the optional-position behavior, the input fields, and the return value. It lacks only the higher-level usage boundaries, which are already penalized under Usage Guidelines.

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 top-level 'params' parameter has no schema description, so the description must compensate. It lists the three fields and enumerates the button choices, and 'current position' implies x and y are optional. It does not explain coordinate origin, bounds, or null behavior, though the nested schema partially fills in optionality and integer ranges.

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 phrase 'Kattintas a megadott (vagy a jelenlegi) pozicion' clearly states a specific action (click) on a resource (mouse position), and the optional-coordinate clause distinguishes it from mouse_move and mouse_double_click. An agent can immediately tell what the tool does without needing to compare 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 no explicit guidance about when to use this tool versus siblings like mouse_double_click, mouse_move, or keyboard interaction. It implies that omitting coordinates clicks at the current position, but it never states exclusions, prerequisites, or 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 indicate the tool is not read-only, not idempotent, and not destructive. The description adds the behavioral detail that it acts on the current position when coordinates are omitted, and that it returns a confirmation string. It does not disclose details like double-click timing or what happens on invalid coordinates, but for a simple mouse action this is acceptable.

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

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

The description is compact and front-loaded: a clear one-sentence summary followed by Args/Returns. No word is wasted, though the Hungarian phrasing and vague 'Megerosites' slightly reduce accessibility.

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 mouse action with a nested schema and an output schema, the description covers the core behavior, current-position fallback, and return type. It does not explain when to use it or edge cases, but combined with the schema it provides 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?

The description merely lists 'params (MouseClickInput): button, x, y' without explaining their semantics. Since schema description coverage is 0%, the description fails to compensate by providing meaning for the parameters; meaningful details are only found in the nested schema property descriptions.

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

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

The description states a specific action ('dupla kattintas' / double-click) on a clear target (specified or current position). This distinguishes it from sibling tools like mouse_click and mouse_scroll, so an agent can tell exactly what operation it performs.

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 verb and the tool name, but the description gives no explicit guidance about when to choose this over mouse_click or mouse_scroll, nor does it state any exclusions. An agent can infer the use case from context, but there is no direct 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 indicate the operation is non-destructive, idempotent, and not read-only. The description adds that it moves to absolute screen coordinates and returns a confirmation string. It does not discuss side effects like hover state or focus changes, but the core behavior is well disclosed.

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

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

The description is concise and front-loaded: one clear sentence stating the action, followed by compact Args/Returns sections. There is no filler or redundant prose.

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 mouse movement tool, the description, annotations, and schema together provide adequate context: behavior, coordinate bounds, idempotency, and non-destructive nature. It does not specify the coordinate origin or multi-monitor behavior, but these are minor for this tool's complexity.

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 reported as 0%, so the description needed to explain x and y semantics, but it only lists the parameter names. The nested schema does define x and y in Hungarian with bounds, which partially mitigates the gap, but the description itself adds no meaning beyond the names.

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

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

The description uses a specific verb and resource: moving the mouse cursor to an absolute screen coordinate. This clearly distinguishes it from siblings like mouse_click, mouse_double_click, and mouse_scroll by naming the exact action and coordinate system.

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

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

The intended use is clear: position the mouse cursor at an absolute screen coordinate. It implicitly separates this from click/scroll operations, though it does not explicitly state when not to use it or name alternative 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 establish that the tool is neither read-only, idempotent, nor destructive. The description usefully adds that scrolling occurs at the pointer's current position and that a confirmation string is returned, but it does not disclose scroll granularity, cumulative effects, or platform-specific behavior.

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

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

The description is compact and follows an Args/Returns structure, with no filler. It loses a point because the main sentence is minimal and the Returns line ('Megerosites') offers only a vague confirmation rather than concrete information.

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

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

For a simple scroll tool with annotations and an output schema, the core behavior is captured. However, the lack of any usage context or edge-case handling (e.g., maximum scroll bounds, whether the pointer moves, or behavior when already at the end) leaves the description only partially 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?

With schema description coverage at 0%, the description only restates the parameter names and accepted direction values ('up'|'down'). It does not clarify what 'amount' means (e.g., number of wheel steps, lines, or pixels) or how negative values could be handled, so the agent must rely on defaults and bounds from the schema.

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

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

The description identifies a specific action ('vertical scroll') and a precise target ('current mouse pointer position'). This is sufficient to distinguish mouse_scroll from sibling tools like mouse_move and mouse_click, and the Args line confirms it applies direction and amount.

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

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

No guidance is given for when to prefer this tool over alternatives such as keyboard scrolling or programmatic scroll actions, and no exclusion conditions are mentioned. The description is purely functional and leaves selection entirely to inference.

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

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

The description adds useful behavior beyond the annotations: 'Ha a cel mar letezik, megerositest ker' (if the target already exists, it asks for confirmation). This clarifies that the tool will not silently overwrite and that confirmation is part of the flow. The annotations already establish destructiveness, so the additional confirmation detail is valuable.

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

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

The description is short and front-loads the core purpose in the first sentence. The Args/Returns section is minimal and somewhat redundant with the schema, but it does not waste much space. Overall structure is clean and scannable.

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 move/rename tool, the description covers the basic operation and confirmation behavior, while annotations and output schema cover safety and return shape. However, it lacks usage context and parameter depth, so an agent is left to infer important details like remote host behavior and response_format choices.

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 reported as 0%, so the description needed to compensate, but it only lists parameter names (source, destination, host) without explaining their meaning or interactions. It also omits response_format entirely. The nested schema has descriptions, but the top-level params wrapper is undocumented and the description adds little beyond names.

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

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

The description clearly states the operation: 'Fajl / konyvtar atnevezese vagy athelyezese' (rename or move a file/directory). This distinguishes it from sibling tools like delete_path, write_file, and make_dir, so an agent can tell which tool handles relocation/renaming.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as delete_path, write_file, or edit_file. The purpose is implied by the description, but no conditions, exclusions, or recommended alternatives 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the tool performs an internet test and returns a summary string, which is useful but not deeply detailed about external network behavior or potential failures.

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

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

The description is short and front-loaded with the core network-diagnostics scope. The Args/Returns section is somewhat redundant with the schema but stays compact and readable.

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

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

For a simple read-only status tool, the description is mostly complete: it enumerates what is checked, mentions a return type, and is supported by schema details for host and response_format plus annotations. It could be more complete with explicit usage guidance, but nothing critical is missing for invocation.

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

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

The description merely restates the parameter names 'host, response_format' without adding meaning. With schema description coverage reported as 0%, the description does not compensate by explaining defaults, remote-host requirements, or response-format choices.

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

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

The description clearly identifies the resource: network interfaces, IP addresses, default gateway, DNS, and an internet test. It lacks an explicit verb like 'get' or 'show', but the scope is unambiguous and distinguishes it from general system-status siblings.

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

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

Usage is implied: the content list suggests this tool is for network diagnostics and internet connectivity checks. However, there is no explicit guidance about when to prefer network_status over system_status, system_info, or other related sibling 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 mark the tool as read-only and non-destructive, so the description does not need to re-establish safety. It adds valuable behavior context by stating the output fields (pid, user, CPU%, MEM%, command) and the filtering/sorting/limit capabilities, going beyond what annotations alone 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?

The description is compact and front-loaded with the core purpose, followed by a concise parameter summary and return specification. There is no filler, repetitive annotation, or unnecessary detail.

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 list tool with rich annotations and detailed schema descriptions, the description is sufficiently complete: it states the resource, supported operations, and return content. It omits explicit alternative-tool routing, but that gap is captured under usage guidelines and does not block correct invocation.

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

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

The description lists all parameter names and the sort_by allowed values, but it adds little meaning beyond the input schema, which already provides detailed descriptions for filter, limit, sort_by, host, and response_format. The schema supplies the semantic weight, so the description's contribution is marginal but not 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?

The description clearly identifies the operation: listing running processes ('Futo folyamatok listaja') and distinguishes it from typical siblings like cpu_usage or memory_usage by specifying the resource as the full process list. However, it does not explicitly name or contrast sibling tools, 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?

The description states what the tool does but gives no guidance on when to prefer it over alternatives, when not to use it, or how it relates to siblings such as system_status, cpu_usage, or memory_usage. Usage context is only implied by the tool name and the phrase 'list of running processes'.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, and the description adds a material behavior: large file contents are truncated. This goes beyond the structured annotations without contradicting them.

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 highly concise: a one-line purpose followed by compact Args and Returns sections. It contains no filler and is front-loaded with the primary operation.

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

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

For a simple read operation, the description covers the core behavior, optional line ranges, and truncation. Combined with the rich schema and safety annotations, it is sufficiently complete; missing details like error behavior and encoding are minor for this 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 description only lists parameter names and does not explain their semantics. However, the embedded schema already documents each parameter in detail (path, line range inclusivity, host semantics, response_format), so the description does not need to repeat that information.

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

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

The description clearly states the operation: reading a text file, optionally limited to a line range. The verb 'beolvasasa' and the object 'szöveges fájl' make the purpose specific and distinguish it from write/edit/list operations, though it does not explicitly name a sibling alternative.

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

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

No explicit guidance is given about when to use this tool versus alternatives like file_info or list_files. The purpose is implied, but there is no when-to-use context, no exclusions, and no mention of prerequisites.

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 readOnlyHint annotation, the description discloses meaningful runtime behavior: it tries gnome-screenshot, scrot, imagemagick 'import', and grim (Wayland) in order. It also explains the two return modes depending on return_image. This is useful behavioral context that annotations alone do not 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?

The description is compact, front-loaded with the core purpose, and organized into clear Args and Returns sections. Every sentence adds information: purpose, fallback behavior, parameter list, and return type. No filler or redundancy.

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

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

For a simple screenshot tool, the description covers purpose, dependencies, parameters, and return value. Since there is no output schema, explaining the Image | str result is necessary and provided. It could be more complete by noting failure behavior when no screenshot tool is available and what happens if save_path is omitted, but it is adequate for an agent to invoke the tool correctly.

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

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

The description lists save_path, window, and return_image, and crucially explains how return_image changes the result type. The schema already documents each property, so the description adds conditional return behavior rather than repeating schemas. It could say more about window support across backends, but it does not merely restate the schema.

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

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

The description opens with 'Kepernyokep keszitese a lokalis asztalrol' — a clear verb and resource, stating exactly what the tool does: take a screenshot of the local desktop. This is distinct from sibling tools like window_list, desktop_ocr, and system_info. No ambiguity remains about the tool's core function.

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 purpose implies when the tool should be used — whenever a screenshot is needed — but the description never explicitly states alternatives or conditions. It does not mention 'use this instead of desktop_ocr for image capture' or any when-not-to-use guidance. The fallback-order line is about implementation, not usage 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context by revealing that it returns raw `systemctl status` output and exposes active/enabled status plus recent log lines.

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

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

The description is compact and front-loaded: one sentence states the purpose, followed by a minimal Args list and a one-line Returns statement. There is no filler or irrelevant detail.

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

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

For a simple read-only status query with strong annotations and a described `str` return, the definition is nearly sufficient. It does not mention required privileges or the local-host default for `host`, but those are partially covered by the schema and are minor for this tool's complexity.

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 merely lists parameter names (`name`, `host`, `response_format`) without explaining defaults, format meanings, or remote-host behavior. Since schema description coverage is 0%, the tool-level description fails to compensate for the lack of structured parameter 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 clearly identifies the resource as a systemd service and specifies the status aspects queried: active state, enabled state, and last log lines. The return value is also stated as `systemctl status` output, making the tool unambiguous next to siblings like `system_status` and `logs`.

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 context is implied rather than explicit: an agent can infer this tool should be used when a systemd service's status is needed. However, no alternatives or when-not-to-use conditions are mentioned, and the remote-host prerequisite appears only in the schema, not in the description.

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, the description reveals the self-elevation prevention mechanism and the environment-variable escape hatch. This is important behavioral context that an agent could not infer from readOnlyHint, destructiveHint, or idempotentHint alone.

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 well-structured and appropriately sized: a one-sentence purpose, a focused security explanation, and a compact Args/Returns block. Every sentence adds meaningful guidance, with the most important usage constraint front-loaded.

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

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

For a simple mode-change tool, the description covers the action, the constraints, the security rationale, the parameter list, and the return value. No critical operational detail 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 Args section merely lists 'mode, persist' with no additional explanation of their meanings, values, or effects. Although the input schema contains some descriptions, the provided context reports 0% schema description coverage, so the description needed to compensate and did not.

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 changes the server's permission mode (SAFE / NORMAL / ADMIN), naming a specific verb, resource, and the possible values. It is distinct from all listed sibling tools, which are system, file, package, or terminal operations rather than mode switching.

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

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

The description explicitly explains when the mode can be lowered versus raised: lowering is always allowed, while raising requires ADMIN mode or the UBUNTU_CONTROL_MODE environment variable. It also explains the security rationale, giving an agent the exact constraints for using the tool safely.

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, and openWorldHint=true, so the safety profile is covered. The description adds a process-level behavioral detail beyond annotations: invoking this tool triggers the same risk gate as host_run, and it openly labels the tool as an arbitrary-command escape hatch. It stops short of explaining what the risk gate entails, but the added context is meaningful.

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

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

The description is front-loaded with the core purpose, followed by risk context, alternative guidance, then args/returns. The Args block partly restates schema content, but the host-field warning earns its place; overall the structure is logical with no filler.

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

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

For a high-risk arbitrary-command tool, this covers purpose, the risk-gate behavior, alternative routing, and the host-field trap. The output schema documents return formats and annotations cover the safety profile, so nothing critical is missing. A short note on what the risk gate actually does would push this to fully 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?

The schema already documents every parameter (command, sudo, timeout, cwd, response_format, host) with descriptions, so the baseline is met. The description adds the single most critical semantic warning: leave 'host' empty or the command will run on a remote machine — a trap an agent would not infer from the schema alone. Minor blemish: it names the type 'HostRunInput' while the schema defines 'RunInput', but the listed fields align.

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, and scope: run a one-time shell command on the LOCAL machine where the MCP server runs. This immediately distinguishes it from host_run (remote) and from the specialized system_* and apt_* siblings, and the 'escape hatch' framing reinforces its role as a general-purpose fallback.

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 explicit routing guidance: prefer the specialized tools (system_*, apt_*, etc.) and use this only as an escape hatch for custom commands. It also warns that the same risk gate applies as for host_run and that filling the 'host' field redirects execution to a remote machine, clarifying when this tool is versus is not 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 provide idempotentHint=true and destructiveHint=false, and the description adds little beyond the basic 'install' action and a return string. It does not disclose side effects, permission requirements, or remote execution behavior, so it fails to add meaningful behavioral context 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 short and front-loaded, but the Args line mostly repeats information already present in the input schema. It is concise yet under-informative, and the terseness prevents it from covering usage context.

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

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

For a tool with siblings like apt_install and snap_remove, plus remote-host options in the schema, the description is too minimal. It does not explain when this tool is appropriate, what happens on the target host, or how the output should be interpreted.

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 description coverage reported at 0%, the description should compensate by explaining parameters, but it only lists their names: packages, host, response_format. It does not clarify which are required, what formats are expected, or that the schema reuses AptPackagesInput for a snap operation.

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 'Snap csomag telepitese' (Snap package installation), identifying a specific action and resource. It is clear about what the tool does and the 'Snap' qualifier separates it from apt-based sibling tools, though it does not explicitly contrast them.

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 snap_install instead of apt_install, apt_upgrade, or snap_remove. The description does not mention prerequisites, remote-host considerations, or exclusions, so an agent receives no decision support for choosing this tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds little beyond saying it returns a string list; it does not describe additional behavior such as remote-host requirements or failure modes. No contradiction exists between the description and 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 extremely concise and front-loaded with the core purpose. It includes a simple Args/Returns structure with no filler or redundant content. Every sentence earns its place for such a simple list 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 simple read-only list tool, the description is largely complete: annotations cover the safety profile, the nested schema covers host and response_format details, and an output schema exists for return structure. The main missing piece is any explicit statement about when to use this instead of other package-related tools, but that is a minor gap.

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

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

The description only lists parameter names ('host, response_format') without explaining their meaning, and the reported schema description coverage is 0%. It does not compensate by describing how to select a host or what response_format values do. An agent would need to inspect the nested schema definitions for actual parameter semantics.

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

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

The description states in Hungarian 'Telepitett snap csomagok listaja' which clearly means 'list of installed snap packages'. It uses a specific verb and resource, and distinguishes itself from siblings like snap_install and snap_remove. There is no ambiguity about what this tool does.

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 that this tool is used when you need to list installed snap packages, but it does not explicitly state when to choose it over alternatives or mention any exclusions. It offers no comparison with related tools like snap_install or apt_list_upgradable, so usage guidance is only implicit.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false; the description adds the meaningful behavioral detail 'Megerositest ker' (asks for confirmation) and states that the output is the removal result. There is no contradiction with annotations.

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

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

The description is short, front-loaded with the purpose, and organized into Args/Returns sections with no filler. It loses a point only because the type name 'AptPackagesInput' is reused for a Snap operation and could introduce mild confusion.

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 tool with strong annotations and a schema that documents host and response_format, the description conveys the essential behavior: removal, confirmation, and returned output. It could add explicit alternative tool guidance, but the missing pieces are minor.

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

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

The description lists the nested fields packages, host, and response_format but adds no meaning beyond the schema, whose $defs already describes host and response_format and gives packages a brief description. This is adequate because the schema carries the parameter 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 action and resource: 'Snap csomag eltavolitasa' (removing a Snap package). It is clear enough to distinguish from apt_remove/snap_install, though it does not explicitly name those siblings.

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

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

No guidance is given about when snap_remove should be preferred over apt_remove, or that snap_install is the inverse operation. The only implicit signal is the 'Snap' wording, so the agent must infer the appropriate context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds context about response formats (markdown/json) and local-vs-remote host behavior, but does not disclose error handling or detailed output structure beyond listing fields. No contradiction with annotations.

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

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

The description is compact and well-structured with Args and Returns sections, front-loading the core purpose. It avoids unnecessary prose, though the Hungarian language and the somewhat redundant Args section prevent a perfect score.

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

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

For a simple read-only information tool, the description covers the returned fields and response formats, and the annotations cover safety and idempotence. The indicated presence of an output schema covers return structure, so the lack of detailed error-case discussion is acceptable.

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's Args section merely repeats parameter names with minimal qualifiers ('host (opcionalis), response_format'), adding no meaning beyond the input schema. The schema itself provides richer descriptions for both host and response_format, so the description fails to compensate for the low schema description coverage signal.

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 provides static system information and enumerates exact fields (OS, kernel, hostname, CPU model, cores, total RAM, uptime). This distinguishes it from dynamic sibling tools like cpu_usage or memory_usage, though it lacks an explicit action verb like 'get' or 'retrieve'.

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 static machine info, contrasting with dynamic siblings, and the schema hints at the host_add prerequisite for remote hosts. However, it does not explicitly name alternatives or state when to use system_info over system_status, cpu_usage, etc. The usage guidance is mostly implicit 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 and destructiveHint=false, so the safe-read nature is covered. The description adds useful detail about the snapshot contents and the summary return format, but it does not disclose potential edge behaviors such as remote-host requirements or command execution context beyond what the schema already notes for host.

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

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

The description is short, front-loaded with the core behavior, and organized into Description, Args, and Returns sections. It is concise, though the Args section adds little beyond the schema and could be trimmed without losing essential information.

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

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

For a simple read-only snapshot tool, the description covers the main metrics returned and the output summary format. The output schema exists and the annotations cover safety, so the description is mostly complete; it only lacks explicit routing guidance relative to similar system inspection siblings.

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's Args line only restates parameter names ('host (opcionalis), response_format') without adding semantic value. The meaningful meaning of host (local vs configured remote) and response_format (markdown/json) comes from the input schema's own descriptions. With the reported 0% description coverage, the description does not compensate for 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 description states a specific verb and resource: it provides a 'quick health snapshot' with CPU%, RAM, swap, disk (/), load average, and top 5 processes. This clearly differentiates it from more focused siblings like cpu_usage, memory_usage, disk_usage, and process_list by presenting itself as a combined overview.

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 'Gyors egeszseg-pillanatkep' implies use for a quick overall health check, but the description gives no explicit when-to-use guidance and does not name alternatives or exclusions. An agent is left to infer which sibling tool fits specific scenarios.

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 idempotentHint=true. The description adds value by specifying the concrete behavior: it closes the terminal session and stops its processes. This clarifies exactly what destructive effect will occur, going beyond the bare annotation flags.

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

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

The description is short, front-loaded with the main behavior, and includes a simple Args/Returns structure. It is appropriately sized for a one-parameter tool, though the Args line is a bit redundant with the schema. Overall it is clean and scannable.

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 terminal-closing tool, the description covers the essential behavior and return value, while annotations and schema fill in destructiveness, idempotency, and parameter meaning. It does not explain when to prefer this over terminal_ctrl_c or terminal_wait, but that gap is more of a usage-guideline issue than a completeness issue.

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's Args section only restates the parameter name 'terminal_id' without adding meaning. Although the context signal reports 0% schema description coverage, the nested schema property does include a description ('A bezarando terminal azonositoja'), giving the agent enough information. The description itself adds no semantic value beyond the schema.

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

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

The description clearly states the action: closing a terminal session and stopping its processes. This is a specific verb+resource combination that distinguishes it from siblings like terminal_open, terminal_read, and terminal_write. However, it does not explicitly contrast with any sibling tool, so it falls short of the top score.

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

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

There is no guidance on when to use this tool versus alternatives such as terminal_ctrl_c or terminal_wait. The description only states what the tool does, leaving the selection context entirely to inference.

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

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

Annotations already signal a non-read-only, non-idempotent operation, and the description matches that by saying a sequence is sent. It adds the return behavior ('confirmation + short output') but does not disclose possible side effects such as interrupting or altering a running terminal process.

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

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

The description is compact: one purpose sentence, one disambiguation sentence, and an Args/Returns block. Every sentence carries information, with no filler or repetition.

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

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

For a simple terminal-control-key tool, the description and schema together give the agent enough to invoke it correctly: terminal_id, key, allowed keys, and the type of return value. It does not provide sibling routing guidance, but that gap is already reflected in usage_guidelines.

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

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

The schema describes terminal_id and key plus the supported values, but the description adds the crucial disambiguation that the tool name is not a restriction: any supported key may be provided in the key field. This prevents an agent from only ever sending ctrl-c and goes beyond the structured fields.

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

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

States a specific action: sending control/device sequences to a terminal, with concrete examples (ctrl-c, ctrl-d, up, tab). The wording makes clear this is not general text writing, which distinguishes it from terminal_write, though it does not explicitly name sibling alternatives.

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

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

The use case is implied: use this tool when the agent needs to send a control key or device sequence to an identified terminal. It does not explicitly contrast with terminal_write, keyboard_press, or other sibling tools, nor does it state when not to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds useful detail about the returned status fields and string format, but it does not disclose edge cases such as empty terminal lists or potential error conditions.

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

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

The description is compact, front-loaded with the core purpose, and includes a useful return-value line without any filler. Every sentence contributes meaningful information.

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

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

For a no-parameter, read-only listing tool, the description covers the scope and return shape well, especially with annotations and an output schema present. It could be slightly stronger by explicitly mentioning that it only lists existing sessions and does not modify them, but that is already implied by the annotations.

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

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

There are no actual user-facing parameters; the only required field is the 'params' wrapper containing an empty object. The schema fully defines this envelope, so the description does not need to add parameter-level guidance.

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 that the tool returns a list of currently open terminal sessions with status, and enumerates the returned fields (id, type, target, alive, idle time, age). This clearly identifies the resource and action, though it does not explicitly distinguish itself from sibling terminal tools.

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

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

The phrase 'currently open terminal sessions' implies the tool is for enumerating open terminal sessions, but the description does not provide explicit when-to-use versus alternative tools, nor any exclusions. The usage context is inferable 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?

The description adds meaningful behavioral details beyond the annotations: it creates a real PTY locally (so curses/screen programs work), uses SSH for remote hosts, and returns a terminal identifier plus initial prompt output. This gives the agent a clear model of what happens when the tool is invoked.

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

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

The description is compact and front-loaded: the main purpose appears first, followed by local/remote behavior, parameters, and return value. Every section contributes useful information without unnecessary fluff.

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

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

The description covers the essential behavior, local/remote distinction, return value, and parameter list. It is slightly light on lifecycle expectations, such as the need to later close the session, but the schema and sibling tool names compensate for most 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?

The description only lists the parameter names (host, shell, cwd, response_format) without explaining them. The input schema provides per-field descriptions, including host defaulting to local and response_format being markdown/json, so the schema 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 clearly states that the tool opens a new, long-lived interactive shell session, and it distinguishes local PTY behavior from remote SSH behavior. It does not explicitly contrast with sibling tools like shell_run or terminal_write, but the core action and resource are unambiguous.

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

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

The description implies usage context by explaining local versus remote sessions and mentions that remote sessions use SSH on a configured machine. However, it does not explicitly state when to prefer this tool over alternatives such as shell_run or when not to use it.

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

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

The description adds a useful behavioral detail beyond the annotations: it returns empty if nothing happened. It also implies an incremental read of newly accumulated output. However, it does not disclose potential blocking behavior related to drain_seconds or whether reading consumes the buffer. Annotations already declare readOnlyHint=true and destructiveHint=false, so the description offering some extra behavior context but omitting these nuances is acceptable.

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 extremely concise: one sentence stating the purpose, followed by a clean Args/Returns block. No filler or repetition. The front-loaded sentence immediately conveys the core function, making it easy to scan.

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

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

For a simple read tool, the description covers the basic operation and return behavior, and the schema handles parameter constraints. However, it omits important context: how to obtain a valid terminal_id (e.g., from terminal_list), whether the terminal must already be open, and what happens if the terminal does not exist. These gaps prevent a fully self-sufficient call in an unfamiliar environment.

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 only lists the parameter names (terminal_id, drain_seconds) without explaining their format, source, or effect. The schema contains short Hungarian descriptions, but the context signal reports 0% schema description coverage, meaning the description must compensate for the lack of usable parameter documentation. It does not, leaving the agent to guess what values are valid and how drain_seconds influences the call.

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

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

The description clearly identifies a specific read operation: 'reading the new output accumulated for the given terminal'. It uses a specific verb and resource, and the scope ('new output') distinguishes it from sibling tools like terminal_write or terminal_list. An agent can tell exactly what this tool does 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 gives no guidance on when to use this tool versus alternatives, does not mention prerequisites (e.g., an open terminal), and does not explain how this relates to siblings like terminal_wait or terminal_list. Usage context must be entirely inferred from the tool name and sibling list.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description only restates that the terminal size is set and adds the curses use-case, which is application context rather than a behavioral trait such as side effects, prerequisites, or errors.

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

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

The description is short and front-loads the core purpose. The Args/Returns block adds structural information without excessive verbosity, though the return type is somewhat redundant given the existing output schema.

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 idempotent terminal-resize operation, the description, annotations, and schema together provide enough to invoke it correctly. It lacks only minor context such as requiring an already-open terminal, which is implied by the terminal_id parameter and sibling terminal tools.

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 lists 'terminal_id, cols, rows' in the Args section but gives no meaning for these fields. Since the context signal reports 0% schema description coverage for the top-level params object, the description fails to compensate; the semantic detail is left entirely to the nested $defs, which the agent may or may not resolve.

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 'Setting the size of a terminal (PTY)', a specific verb and resource that clearly identifies the operation. It also contextualizes the purpose for curses programs (htop, vim), but it does not explicitly contrast it with sibling terminal tools such as terminal_open or terminal_write.

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

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

It provides a concrete use case ('important for curses programs') that implies when the resize is needed, but it neither names alternative tools nor states when not to use it. The guidance 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?

The description goes beyond annotations by explaining the two termination conditions (regex match or output idleness) and the return value (collected output plus whether the pattern was found). This is useful behavioral context that the readOnlyHint alone does not provide. It does not mention timeout error handling, but the schema covers timeout bounds.

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

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

The description is compact and well-structured: main behavior first, then usage examples, then a brief args/returns summary. Every sentence earns its place, and there is no redundant fluff.

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

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

For a wait operation with annotations and full schema descriptions, the description covers the core behavior, common usage, and return value. It does not explicitly address timeout failure behavior, but the return format implies partial output is returned. Overall, an agent has enough context to invoke the tool correctly.

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

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

The description only lists parameter names (terminal_id, pattern, timeout, idle) without adding meaning. However, the input schema provides detailed descriptions for each property, including regex behavior and idle semantics. Since the schema carries the semantic weight, the description adds no extra value, yielding the baseline score of 3.

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

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

The description states a clear verb and resource: wait on a terminal until a regex pattern appears or the output goes quiet. The examples (build, install, server startup) reinforce the intended operation. It does not explicitly contrast with siblings like terminal_read, but the wait-for-condition behavior is distinct and unambiguous.

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

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

The description gives concrete use cases: long-running commands and server startup with a known readiness string. This tells an agent when to call it. It does not mention when not to use it or name alternative tools, but the provided context is sufficient for typical scenarios.

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 that this is a non-read-only, non-idempotent operation. The description adds that the tool returns a confirmation and, when read_after is true, the new terminal output, but it does not go deeper into side effects of command execution. The word "parancs" and openWorldHint convey active behavior, so the description is adequate but not rich.

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

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

The description is short, front-loaded with the core purpose, and structured into Args and Returns sections. Every sentence serves a function, and there is no filler or needless repetition of schema details.

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

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

For a terminal write tool, the definition covers the essentials: target terminal, text, optional Enter, optional read-back, and return value. The open-terminal prerequisite is implied and reinforced by the schema's terminal_id description. It does not expand on command-execution risks, but the annotations and the word "parancs" communicate that this is an active operation.

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's Args line only lists the parameter names (terminal_id, data, enter, read_after) and adds no semantic detail. The nested schema provides full descriptions for all four fields, so the agent has the needed meaning, but the description itself contributes no additional parameter value.

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

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

The first sentence, "Szoveg / parancs kuldese egy nyitott terminalba", names a concrete write action and a specific target resource (an open terminal). It clearly differentiates this tool from siblings like terminal_read, terminal_open, and terminal_ctrl_c by emphasizing the act of sending text or commands.

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 terminal must already be open, and the schema connects terminal_id to terminal_open. However, it does not explicitly say when to prefer this over keyboard_type or terminal_ctrl_c, and it provides no when-not-to-use 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 mark the action destructive and readOnly=false; the description adds a meaningful warning that unsaved work may be lost and that force triggers a confirmation prompt. This gives the agent risk context beyond the structured hints.

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 extremely compact: one sentence for the core action, one for the dangerous force mode, followed by a clean Args/Returns skeleton. Every sentence contributes without filler.

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

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

For a simple destructive close action, the description covers the main behavior, the force warning, and the return type. It is missing usage direction and any note on prerequisites such as obtaining a window identifier from window_list, so it is adequate but not fully 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?

The Args line merely names query and force without explaining them, so the tool-level description adds little semantic value. However, the nested schema provides clear descriptions for both parameters, making the overall definition sufficient for correct invocation.

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 concrete verb+resource: 'Egy ablak bezarasa' (closing a window), and the force-mode warning clarifies the action. It does not explicitly contrast with sibling tools like window_focus or window_list, so it stops short of full sibling differentiation.

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

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

There is no guidance on when to choose window_close over alternatives such as window_focus or window_list. The only conditional mentioned is force-mode confirmation, which is more about behavior than usage 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?

Beyond the annotations, the description discloses the concrete behavioral effect — raising the window to the front and focusing it — and states that a confirmation string is returned. It does not cover edge cases like a missing window, but the idempotent and non-destructive hints already cover the safety profile.

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 extremely concise: one meaningful action sentence plus a minimal Args/Returns docstring. There is no filler or redundant explanation.

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

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

For a simple one-parameter, idempotent, non-destructive tool with an output schema, the description is largely complete. The only notable gap is behavior when no matching window is found or whether minimized windows are restored.

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 paraphrases the query parameter's meaning as a title fragment or identifier, which matches the input schema's own description. It adds no extra detail such as the exact 0x... ID format or any additional constraints, so it does not significantly go beyond what the schema already provides.

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: bring a window to the foreground and focus it, selecting by title fragment or ID. This clearly separates it from siblings like window_list and window_close.

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 use case is implied: focus an existing window when you have a title fragment or window ID. However, it does not explicitly mention when not to use it or point to alternatives such as window_list for discovering window IDs.

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, and the description does not contradict any of these. It adds useful behavioral detail beyond annotations by specifying that it runs 'wmctrl -l' and returns a list with four fields, giving the agent a concrete picture of the operation. No side-effect warnings are necessary given the read-only nature.

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

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

The description is short and front-loaded with the main purpose, followed by a returns line. The bilingual Hungarian/English text is a minor friction point, and 'Returns: str: Ablaklista' is slightly redundant with the opening sentence, but the structure is otherwise economical.

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, zero-parameter list tool with safety annotations, the description sufficiently covers what is returned and the included fields. It does not mention output formatting details beyond the field names, but the presence of an output schema or the trivial nature of the tool makes this acceptable.

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

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

The schema only requires an empty params object, effectively meaning there are zero real parameters. With 0 parameters, the baseline is 4, and the description has no obligation to explain parameter behavior. It correctly adds no parameter-related text.

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: it lists open windows ('A nyitott ablakok listaja'), names the exact command (wmctrl -l), and enumerates the returned fields (azonosito, asztal, gep, cim). This clearly distinguishes it from sibling tools like window_focus and window_close, which operate on windows rather than list them.

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 when an agent needs to enumerate open windows, but it gives no explicit when-to-use guidance and does not mention how this relates to alternatives such as window_focus or window_close. There are no exclusion criteria, so the guidance is only implicit.

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

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

Annotations already mark the tool as destructive and non-read-only; the description adds useful behavior by stating that overwriting an existing file requires confirmation and that the return value is the number of bytes written. This goes beyond the annotations without contradicting them.

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

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

The description is compact and front-loaded with the main purpose, followed by a brief Args and Returns breakdown. The Args line is somewhat redundant with the schema, but the overall structure is scannable and not bloated.

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

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

The description covers the essential action and the key destructive-behavior caveat, and the schema/annotations fill in parameter and safety details. It lacks an explicit pointer to edit_file for partial edits and does not clarify how the overwrite-confirmation is surfaced to the agent, making it adequate but not fully 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?

The input schema's nested properties provide descriptions for all relevant parameters, including path, content, append, create_parents, host, and response_format. The description only repeats an abbreviated parameter list and omits response_format, so it contributes little semantic value beyond the schema.

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

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

The description clearly states the tool's action: creating, overwriting, or appending to a file, with explicit mention of confirmation when overwriting. This distinguishes it from read, delete, list, and move siblings, though it does not explicitly differentiate it from the edit_file 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 core use case is implied by the description: use this tool to create, overwrite, or append to a file. However, there is no explicit when-not-to-use guidance or mention of alternatives like edit_file for partial modifications, so the usage guidance remains somewhat implicit.

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