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

With no annotations, the description carries the behavioral disclosure burden. It discloses the audit domains and system-wide scope, implying a non-mutating read operation, but it does not state return format, side effects, or potential runtime cost. This is minimally 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 a single concise sentence that front-loads the key verb and resource, then enumerates the audited areas. Every phrase adds meaningful 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 zero-parameter audit tool, the description gives sufficient context about what areas are inspected. The absence of an output schema is not fully compensated by describing return values, but the low complexity and clear scope make the definition adequate.

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

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

The tool has zero parameters and the schema is empty, so there are no parameter semantics to clarify. Per the baseline for zero-parameter tools, this dimension is well satisfied by the description's scope statement.

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 the specific verb 'Audit' and names the exact resource scope: 'system-wide yarn health, runtime dependencies, layer overrides, and schemas.' This clearly identifies what the tool operates on and distinguishes it from the sibling tools, none of which target yarn integrity.

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

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

The description conveys a clear read-only audit context and system-wide scope, so an agent can infer when to invoke it for health/integrity checks. It does not explicitly state when not to use it, but no sibling tool overlaps with yarn auditing, so alternatives are not needed.

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

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

With no annotations, the description must carry the behavioral burden. It states 'cancel/terminate' implying a destructive action, but does not disclose side effects, reversibility, impact on other strands, or what the response contains. This is minimal disclosure for a mutation 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?

A single, efficient sentence that front-loads the action and resource. No wasted words, and the key identifier is stated upfront.

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 operation with no output schema and no annotations, the description is incomplete. It does not explain what happens after cancellation, whether confirmation is provided, or any consequences. An agent cannot fully anticipate the tool's behavior from this description alone.

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 100% (the only parameter, strand_name, is well-documented as 'name or task ID'). The description repeats that but adds no new meaning, so it adds no value beyond the schema. Baseline 3 applies.

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 (cancel/terminate) and the resource (strand execution), and specifies the identifier (task ID or strand name). It is distinct from sibling tools like process_kill, which targets processes, so an agent can readily understand its purpose.

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

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

The description implies it is for currently running strands but does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or prerequisites. There is no comparison to process_kill or other cancellation tools, 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?

No annotations are present, so the description carries the full burden. It states the capture scope ('active screen and windows') but does not disclose whether the tool returns an image, saves a file, requires a display, or behaves differently in headless environments.

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

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

The description is a single, front-loaded sentence with no filler. 'Screenshot snapshot' is slightly redundant, but overall it is appropriately concise.

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

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

For a tool with no output schema and no annotations, the definition leaves a significant gap: it does not say what the agent receives after capture (image data, file path, etc.) or what prerequisites exist. Purpose is clear, but the operational result is unknowable.

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, 'purpose', is fully described in the schema as 'Optional reason for capturing screen.' With 100% schema coverage, the description does not need to compensate, and adding no param-specific detail is acceptable.

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 ('capture') and a clear resource: a high-resolution screenshot of the active screen and windows. It is immediately distinct from the listed sibling tools, none of which perform screen capture.

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, and no alternative capture tool is referenced. An agent cannot infer selection criteria from the description or the 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'fetch and read' but does not mention potential timeouts, redirects, size limits, error handling, or whether it returns raw HTML or stripped text. This is a significant gap for a network operation.

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

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

The description is a single, concise sentence with no wasted words. It is front-loaded with the main action and resource.

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 tool with no output schema and no annotations, the description is adequate but minimal. It implies the output is text content but does not elaborate on limitations or edge cases, leaving some ambiguity for an agent.

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 description covers the url parameter completely (100% coverage), so the description adds no extra meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool's action ('Fetch and read') and resource ('text content of a web page URL'). It is unambiguous and distinguishes from the sibling 'search_web' by focusing on retrieving a specific page rather than searching.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention that search_web is for queries, nor does it specify any exclusions or prerequisites. The description is silent on usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'change permissions mode' but does not mention that this is an irreversible filesystem mutation, that appropriate privileges may be required, or what the return/error behavior is.

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

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

The description is a single, efficient sentence with no filler. It conveys the core operation immediately and wastes no words.

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 two-parameter tool with fully documented schema, the description is adequate. However, with no annotations and no output schema, it leaves implicit assumptions about return values, permission requirements, and failure modes.

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 100%, with both 'path' and 'mode' already documented clearly, including an octal example for mode. The description adds no additional parameter meaning beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the verb ('Change permissions mode') and the resource ('a file or directory path'). It is specific enough to distinguish file_chmod from sibling tools like file_read, file_write, and file_op.

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

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

The description gives no guidance on when to use this tool versus alternatives, such as file_op or other file-related siblings. There is no mention of prerequisites, whether it applies only to local paths, or when chmod would not be 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?

No annotations are provided, so the description must disclose behavioral traits, but it does not. It does not mention whether the search is recursive, whether hidden files are included, or whether results are absolute or relative paths. The operation is clear but these ambiguities remain.

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

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

A single, front-loaded sentence with no wasted words. It immediately states the core action and the key qualifiers (glob pattern, directory path) – the essence of the tool.

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

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

For a tool with two parameters, complete schema coverage, and no output schema, the description is adequate but leaves out useful context like recursive behavior and result format. It could also differentiate itself from file_list, which would improve an agent's selection accuracy. Given the low complexity, a 3 is reasonable.

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 100%, so the schema documents both path and pattern. The description restates the same meaning ('glob pattern', 'directory path') without adding semantics like relative vs absolute paths or default behavior for path='.'. Baseline 3 is appropriate since schema does the heavy lifting.

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

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

States a clear verb ('Search') and resource ('files') plus the distinguishing glob pattern and directory path. It differentiates from file_list and other file tools by being pattern-based rather than direct listing.

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

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

The description implies when to use it (pattern-based search) but provides no explicit alternatives, conditions, or exclusions. It does not mention file_list as a simpler alternative or when one should prefer a direct list over globbing.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden, but it only says 'list files and directories' without stating whether the listing is recursive, whether hidden files are included, whether metadata (size, type) is returned, or what the response format is. For a read operation, the agent gets no confirmation of safety or scope beyond the bare statement.

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

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

A single, front-loaded sentence with zero filler. Every word carries meaning, and the core purpose is stated immediately. Perfectly sized for a simple 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?

The tool is simple (one optional parameter, no nested objects), but with no output schema and no annotations, the description should clarify key listing behaviors like recursion and hidden-file handling. It is adequate for basic use but leaves important details unspecified that an agent would benefit from knowing.

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 100%, so the schema already documents the single 'path' parameter well (with default and meaning). The description adds minimal extra value by implying the path is where to list from, but does not go beyond the schema — the baseline 3 applies.

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 (List) with a clear resource (files and directories) and scope (target directory path). It states what the tool does, but doesn't differentiate it from overlapping siblings like file_find or file_stat, leaving the agent to infer distinctions on its own.

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 on when to use this tool versus alternatives such as file_find (for searching by pattern) or file_stat (for metadata of a single entry). No exclusions, prerequisites, or routing hints are given, so the agent must guess which tool fits.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It discloses no side effects, no permission requirements, no read-only vs mutating distinction, and no inotify lifecycle behavior. The phrase 'File system operations' gives no behavioral grounding for a tool that can write, replace, chmod, and watch.

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 one compact sentence that lists the major capability areas without padding. It is easy to scan, though broader than a single-action tool and partly restates the tool name.

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

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

With 12 parameters, 17 operations, no output schema, and no annotations, this description is severely under-specified. It does not connect operations to required parameters, indicate return shapes, or explain watch/data-flow semantics, so an agent cannot reliably call this tool from the description alone.

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

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

Schema coverage is 100%, so each parameter already has a description in the input schema. The tool description itself adds no parameter-level meaning, but the baseline of 3 applies because the schema handles the semantic burden.

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 broad capability areas ('File system operations, directory navigation, permissions, disk usage, and inotify monitoring'), which conveys the subject domain. However, it lacks a specific verb and does not distinguish file_op from the many dedicated sibling tools like file_read, file_write, inotify_watch, or storage_disk_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?

There is no guidance about when to use this generic dispatcher versus the specialized sibling tools. The description provides no 'use this when' or 'prefer alternative when' information, leaving the agent to infer usage from the operation enum alone.

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

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

No annotations are provided, so the description carries the full burden. It states the core read behavior but does not disclose potential errors, encoding assumptions, or return format. It is not misleading but is minimal.

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

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

A single, clear sentence with no extraneous detail. The essential purpose is front-loaded, and there is no wasted wording.

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 with a fully documented schema, the description covers the primary purpose and the optional line ranges. It doesn't mention edge cases or output details, but given the low complexity, this is adequate.

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 100%, with each parameter already documented. The description adds 'optional start and end line ranges' which maps to start_line and end_line, but it doesn't add meaning beyond the schema's own descriptions, including 1-indexing.

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

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

The description states a specific verb ('Read') and resource ('contents of a text file'), and distinguishes itself from sibling file tools like file_write, file_stat, and file_list. The mention of 'optional start and end line ranges' adds specificity.

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 reading text files, but it doesn't explicitly state when to use it over alternatives like file_stat or file_list. It lacks explicit when-to-use/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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states that text is replaced, which implies file mutation, but it does not disclose that modifications are destructive or irreversible, nor what happens when the target substring is absent.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to the core 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?

The tool mutates a file and has no output schema or annotations, yet the description omits critical semantics such as whether all occurrences or only the first are replaced, and what happens if the target is not found. An agent could call this incorrectly because of that ambiguity.

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 already documents all three parameters at 100% coverage, so the description adds limited new semantic value. The phrase 'exact text substring' usefully reinforces matching behavior but is not strictly necessary given the schema 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 names a specific verb and resource ('Replace exact text substring within a target file'), making the operation unambiguous. It clearly distinguishes itself from broader siblings like file_read, file_write, and file_op by emphasizing 'exact text substring.'

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 file_write or file_op, nor does it state when it should not be used. The operation is implied by the name and description, but the agent gets no explicit decision-making 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?

With no annotations, the description carries the burden of disclosing behavior. It accurately conveys a read-only operation and enumerates the returned metadata categories, but it does not mention behavior on missing paths, symlinks, or directory targets beyond the schema note.

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

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

A single front-loaded sentence with no filler. Every word contributes to identifying the operation and output categories.

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 read-only tool with no output schema, the description covers the essential invocation context and expected output categories. It could add return structure or error behavior, but these are minor for a simple stat 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?

Schema description coverage is 100% and the single path parameter is already well documented as 'Target file or directory path.' The description adds no parameter semantics; it actually narrows the target to 'a file path,' which is slightly inconsistent with the schema's broader directory support.

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 ('Get') and resource ('stat metadata, permissions, size, and timestamps'), making it clear the tool returns filesystem metadata rather than file content or listings. This distinguishes it from sibling tools like file_read and file_list.

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 indication of when to use file_stat versus related sibling tools, nor does it mention any exclusions or alternative tools. An agent must infer applicability solely from the tool name and listed output fields.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose the key destructive side effect of overwriting existing content and restricts the operation to text content. However, it omits other important behavioral details such as whether missing parent directories are created, permission requirements, or failure behavior.

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

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

A single, focused sentence with no filler words. The core action and target are front-loaded, and every word contributes meaning.

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

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

The tool is simple with two required parameters and no output schema, and the description plus schema is sufficient for a basic invocation. However, it lacks guidance on choosing this tool over sibling write variants and does not mention behavioral constraints, making it only minimally viable for a mutation tool with no 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?

Schema description coverage is 100%, as both 'path' and 'content' have descriptions in the input schema. The tool description adds no extra parameter semantics beyond the schema, so the baseline score of 3 applies.

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: 'Write or overwrite text content to a target file path.' It clearly conveys the operation and target, but it does not explicitly differentiate itself from sibling tools like file_replace or file_op, so it stops short of complete sibling discrimination.

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 file_write versus alternatives such as file_replace, file_op, or file_chmod. It neither states scenarios, prerequisites, nor exclusions, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the burden. The verb 'List' implicitly indicates a read-only operation, but the description does not explicitly state side-effect freedom or any other behavioral traits (e.g., permissions, performance). It is adequate for a simple query 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?

A single, front-loaded sentence with zero filler. The core purpose is stated immediately and completely.

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

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

For a parameterless list operation with no output schema, the description fully covers what the tool does. It even hints at the return content ('descriptors and paths'), which is sufficient 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?

With zero parameters, the description has no parameter details to add. The baseline for no parameters is 4, and the description correctly avoids adding unnecessary parameter 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 states a specific verb ('List') and resource ('all active inotify watch descriptors and paths'), clearly distinguishing it from siblings like inotify_watch (add) and inotify_unwatch (remove). No ambiguity remains.

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 'List' – it is the natural way to see current watches. However, there is no explicit guidance on when to prefer this over siblings, though the sibling operations are clearly distinct in purpose.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions polling and 'available' events, but does not disclose that reading events may consume them from the kernel queue, whether timeout_ms causes blocking, or what happens when no watches are active.

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 one concise sentence with the verb and object front-loaded. It contains no filler or redundant restatement.

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 two-parameter polling tool, the description plus schema covers the basics, but it leaves important context unstated: event consumption semantics, behavior when no events are available, and how this differs from inotify_wait_event. These gaps matter because there is no output schema and no annotations to clarify behavior.

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 100%, so the parameters are already documented by their own descriptions. The tool description adds only slight context with 'poll' and 'available', but no meaningful parameter semantics 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 uses a specific verb ('Poll and read') and a clear resource ('available inotify kernel events from active watches'). It is distinct from unrelated siblings, though it does not explicitly contrast itself with inotify_wait_event.

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 inotify_wait_event, or how it relates to inotify_watch. The phrase 'active watches' implies a prerequisite, but the conditions for using this tool versus alternatives are left 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action and the 'active' qualifier but does not describe side effects (e.g., error if watch doesn't exist), reversibility, or any required permissions. For a mutating operation, this is a notable gap.

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

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

The description is a single, front-loaded sentence that states the action and the parameter type with zero waste. It is concise and to the point, fulfilling the requirement that 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 tool with one parameter and no output schema, the description is minimally adequate. It tells the agent what it does and what the parameter is, but it omits details about error handling or consequences of removal. Given the simplicity, this is a borderline acceptable level, though more behavioral context would improve it.

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 describes the single parameter 'watch' as 'Watch descriptor ID or path.' The description repeats this information ('by descriptor ID or path') without adding extra meaning like format requirements or how to obtain the descriptor. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Remove'), a resource ('inotify watch'), and the method ('by descriptor ID or path'). It clearly distinguishes from sibling tools like inotify_watch (create) and inotify_list_watches (list), making 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 implies usage (when you want to stop monitoring a file/directory) but does not explicitly state when to use it over alternatives or mention any preconditions. Since it's a straightforward removal counterpart to inotify_watch, the usage is somewhat self-evident, but there's no explicit guidance.

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

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

With no annotations, the description must disclose behavior itself. It does reveal that the call blocks synchronously, which is useful, but it does not state what happens on timeout, whether an existing watch is required, whether the event is returned, or whether the wait can be interrupted.

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

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

A single front-loaded sentence with no filler. It names the action, the operation mode, the resource, and the target. Every word 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 tool with no annotations and no output schema, the description is too thin. It leaves unclear the relationship to inotify_watch, timeout behavior, return value, and error conditions, which an agent would need to invoke and interpret results correctly.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds the notion of 'specific' event selection, which loosely maps to the 'events' parameter, but it does not meaningfully enrich the semantics 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 verb ('wait') and resource ('a specific filesystem event on a path'), and 'synchronously' differentiates it from async or read-style siblings like inotify_read_events. However, it does not explicitly name any sibling or contrast with alternative tools, so it stops short of full 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 about when to use this tool versus inotify_watch, inotify_read_events, or other siblings. The word 'synchronously' implies blocking usage, but no explicit context, prerequisites, or exclusions 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?

Annotations are absent, so the description carries full burden. It states the action but does not disclose that the tool is non-blocking, returns a watch descriptor, or that the watch persists until removed. It also does not mention whether the watch is registered globally or per session, which is critical operational context for an agent.

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

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

The description is a single, clear sentence with no redundancy. It is efficiently structured, though it could be expanded slightly without becoming verbose.

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?

Without annotations or an output schema, the description fails to provide enough context. An agent does not know how this tool fits into the inotify workflow (e.g., that watches must be created before events can be read), nor what the return value is. The description is too minimal for 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?

Schema coverage is 100%, so parameters (path, events, recursive) already have descriptions. The tool description adds no extra meaning about the parameters beyond the target being a file or directory, which is redundant with the schema. Baseline 3 applies because the schema covers the details.

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

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

The description states a specific verb ('Add') and resource ('Linux inotify kernel watch') with a target ('file or directory'). It clearly indicates the action and resource, but does not explicitly differentiate from sibling tools like inotify_wait_event or inotify_read_events, though the verb 'add' distinguishes from list/read/unwatch 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 provided on when to use this tool versus the sibling inotify tools. There is no mention that this tool only sets up the watch and that one must later call inotify_read_events or inotify_wait_event to consume events. The intended usage context is left 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?

With no annotations, the description carries the full burden of disclosing behavioral traits. It says 'Launch' which implies starting a process, but it doesn't disclose whether the call blocks, returns a process ID, requires a display, or what happens on failure. The only extra behavior mentioned is 'routed through UWSM scope if active', which is cryptic and not explained. This is insufficient for a mutation-like 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 a single, efficient sentence that front-loads the main purpose. It contains no filler or redundancy. However, it is slightly terse, omitting some useful context that could be included without sacrificing conciseness. Overall, it is well-structured for its length.

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

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

Given the tool's simplicity (2 parameters, no output schema), the description is minimally adequate but lacks important context. It does not mention return behavior, whether the call is asynchronous, or how the 'is_tui' parameter affects execution. Given the sibling tool run_command, the description could better clarify when to use this tool versus a generic command runner. The UWSM scope mention is unexplained, leaving some ambiguity.

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 has 100% description coverage, with both 'app' and 'is_tui' described clearly. The tool description adds no additional meaning beyond the schema. Since the schema already provides adequate semantic detail, a baseline of 3 is appropriate. The description does not enhance parameter understanding.

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 (launch) and resource (desktop application or background command), which is specific enough to indicate the primary action. However, it does not explicitly differentiate from sibling tools like run_command, leaving some ambiguity about when to prefer this over a generic command runner. The mention of 'UWSM scope' adds a context clue but doesn't clarify the exact distinction.

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

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

No guidance is provided on when to use this tool versus alternatives such as run_command. The description does not state any conditions, exclusions, or prerequisites. The UWSM scope note is a routing detail, not a usage guideline. An agent would have to infer when to choose this over other process-related 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?

No annotations are provided, so the description must disclose behavioral traits. It mentions it checks via PackageKit D-Bus, implying a read-only operation, but does not confirm that it does not modify system state, nor does it describe side effects like cache refreshing or network access. This leaves ambiguity for a system 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?

A single, clear sentence with no redundant details. It is front-loaded with the action and scope, and every word adds value. Excellent for conciseness.

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 zero parameters and no output schema, the description is mostly sufficient for basic calling. However, it lacks information on return format or properties (like a list of updates), which could be important. It also does not mention any prerequisites like needing to refresh the cache. Overall, adequate but with room for more detail on output or typical 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 tool has zero parameters, and the schema already covers 100% of the parameter information. The description adds context about the underlying mechanism (PackageKit D-Bus), which is beyond schema. Since there are no parameters, the description need not do much here.

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 checks for pending package and system software updates via PackageKit D-Bus. It uses a specific verb 'check' and resource 'pending package and system software updates', and is distinguishable from sibling tools like packagekit_install and packagekit_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 it is for querying pending updates but does not provide explicit when-to-use guidance or contrast with alternatives like packagekit_search or packagekit_get_details. It is clear enough for general use but lacks explicit 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?

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a read operation via PackageKit D-Bus and names some returned fields, but it does not explain failure behavior, whether a bare package name is sufficient for the D-Bus call, whether network access is needed, or what the output structure looks like.

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

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

The description is a single front-loaded sentence that names the action, the resource, and the key metadata categories. Every phrase contributes 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?

The tool is simple, but with no output schema and no annotations, the description is thin for safe invocation. It omits expected return shape, error conditions, and usage context, and it does not relate to any sibling packagekit 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 input schema already describes the only parameter with 100% coverage, including an example, so the description adds little semantic value. The phrase "for a package" loosely matches the schema's "Name of package to inspect" without clarifying any package ID or format nuances.

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 clear verb-resource pair, "Get detailed metadata," and enumerates the specific package information returned: description, license, and repository info. It distinguishes this from a broad search, but it does not explicitly differentiate itself from sibling tools like packagekit_search or packagekit_what_provides.

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 instead of the many packagekit siblings. It does not state prerequisites (e.g., whether the package must be installed), exclusions, or alternatives, leaving the agent to infer usage solely from the tool name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions non-interactive operation and Polkit authorization, which hints at privilege requirements, but it does not disclose system-modifying side effects, possible failure modes (e.g., package not found, dependency conflicts), or what happens if a package is already installed. This is insufficient for a mutation tool without any annotation coverage.

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

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

The description is a single, front-loaded sentence that starts with the action and resource, then adds technical context. There is no filler or redundancy, making it highly concise and well-structured for quick parsing.

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

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

The description is minimally viable for understanding what the tool does, but it lacks detail on important operational aspects: whether it modifies the system, how success/failure is communicated, and what error conditions might arise. Given the lack of annotations and output schema, an agent would likely need additional context to handle edge cases effectively.

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 100%, so the parameter 'packages' is fully documented in the schema (space- or comma-separated list). The description adds no extra meaning beyond that, so a baseline of 3 is appropriate. It does not clarify details like encoding, defaults, or formatting edge cases that are not already in 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 (install) and the resource (one or more packages), distinguishing it from sibling tools like packagekit_remove and packagekit_search. The added context of non-interactive installation and delivery via PackageKit D-Bus with Polkit authorization 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 explicit guidance on when to use this tool versus alternatives. It implies scripted use via 'non-interactively' but does not mention prerequisites (e.g., checking for existing packages) or conditions that would make another sibling tool more appropriate. No exclusions or alternative-selection criteria are offered.

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

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

With no annotations, the description must carry the safety profile. It says 'refresh' which implies modifying system state (likely requires root privileges), but it doesn't disclose potential side effects, whether it triggers network downloads, or if it requires elevated permissions. This is a gap for a system-level operation.

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

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

One sentence, no fluff, directly states what it does and the method. The purpose is front-loaded in the first few words.

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 a single optional parameter with good schema documentation, but no output schema. The description doesn't explain what happens when the refresh completes (e.g., returns void or a success indicator). For a simple tool, this might be sufficient, but given the system-level nature, a note on permissions or side effects would improve completeness.

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

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

The schema has 100% coverage for the single parameter 'force', with a description 'Force download of all repository databases.' The description text adds the context that it's about refreshing the cache, but the parameter is already well-documented. The high schema coverage raises the baseline, so this is adequate.

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

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

The description states the verb 'refresh' and the resource 'package manager repository metadata cache' via PackageKit D-Bus, which is clear. However, it doesn't differentiate from siblings like packagekit_check_updates, which also deals with metadata, but the action (refresh cache vs. check for updates) is distinct enough.

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 when-to-use or when-not-to-use guidance. It implies it's for refreshing the cache, but doesn't mention alternatives like packagekit_check_updates for just checking. Sibling names suggest checking updates is separate, but the description doesn't clarify.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It mentions only the remove action and transport, and does not disclose privilege requirements, whether removal is irreversible, how autoremove affects dependencies, or what the caller should expect on success/failure.

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

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

The description is one short sentence that front-loads the action and resource before mentioning the transport. Every word earns its place and nothing is padded.

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?

This is a destructive system-mutating operation with no annotations and no output schema, but the description does not mention auth expectations, return/error behavior, or PackageKit transaction concerns. The schema covers parameters well, but the operational context is too thin for a removal 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?

Schema description coverage is 100%, so the parameters are already fully documented. The description adds only the 'installed' and 'one or more' constraints, which is marginal beyond what the schema already communicates.

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 ('Remove...packages') and the transport ('PackageKit D-Bus'), so an agent knows exactly what operation is being offered. It is clearly distinguished from sibling tools like packagekit_install and packagekit_search.

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 case is explicit: this is the tool to call when installed packages should be removed. It does not name alternatives or exclusion conditions, so it stops just short of full 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?

No annotations are provided, so the description carries the behavioral burden. The word 'Search' implies a read-only operation and 'via PackageKit D-Bus' gives implementation context, but the description does not disclose return format, whether live repositories are queried, or any authorization/error 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 a single dense sentence with the key verb and resource front-loaded. There is no filler or redundant repetition of 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?

With only two optional parameters and a clear schema, invocation is mostly covered. However, since there is no output schema or annotations, the description leaves result shape and some operational details unspecified, 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 100%; query and limit are already fully documented in the input schema. The description adds no parameter-specific meaning beyond restating that package search is performed.

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

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

The description names a specific action ('Search') and resource ('packages'), and adds meaningful scope ('available or installed', 'distribution repositories', 'via PackageKit D-Bus'). This clearly separates it from packagekit_install, packagekit_remove, and packagekit_refresh_cache, though it does not explicitly contrast with packagekit_what_provides.

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 only implied by the word 'Search'. There is no explicit guidance on when to prefer this over packagekit_what_provides or packagekit_get_details, and no exclusions or alternative routing is mentioned.

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

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

No annotations are provided, so the description carries the full burden. 'Find' and 'provides' signal a read-only lookup and the D-Bus transport is mentioned, but there is no disclosure of potential PackageKit side effects such as metadata refresh or network access, permissions, or behavior when no match is found.

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

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

A single telegraphic sentence that front-loads the core action and object with no filler. Every word contributes to understanding what the tool does.

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 read-only lookup, the description plus the schema are sufficient to invoke it correctly. It could optionally mention the output shape or failure case, but that is not essential 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?

Schema coverage is 100%, and the description's phrase 'file path or binary' adds no meaning beyond the parameter description, which already provides examples and absolute-path guidance. The schema fully documents the only parameter, so the baseline 3 applies.

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 ('Find which package provides') against a specific target ('a specific file path or binary') and names the integration via PackageKit D-Bus. This clearly distinguishes it from sibling tools like packagekit_search or packagekit_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?

The description implies the use case—mapping a file path or binary to its owning package—but it never explicitly names alternatives or conditions for choosing this tool over packagekit_search or packagekit_get_details. An agent can infer when to use it, but no explicit guidance is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not explain the return value, whether a denial reason is included, whether allow_user_interaction can trigger a system prompt, or any side effects of checking authorization.

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

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

The description is a single, front-loaded sentence with no filler. It immediately identifies the action and the resource, 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?

The tool is simple, has full schema documentation, and a read-only 'check' purpose, so the description is minimally adequate. However, with no output schema and no behavioral notes, the agent is left without explicit information about the authorization result format or interactive-prompt behavior.

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

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

Schema coverage is 100%, so all three parameters already have descriptions in the schema. The tool description adds no parameter-level meaning beyond what the schema provides, which meets the baseline but does not exceed it.

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 ('Check authorization'), a specific resource (Polkit action ID), and the target interface (org.freedesktop.PolicyKit1.Authority). This makes it clearly distinguishable from sibling tools such as polkit_pkexec, polkit_list_actions, or polkit_generate_policy.

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 about when to use this tool versus alternatives like polkit_pkexec or polkit_list_actions. No preconditions, exclusions, or decision rules are provided; the only implied usage is the purpose stated 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?

Annotations are absent, so the description bears the full burden of behavioral disclosure. It merely says 'generate' without mentioning whether the XML is returned, written to output_path, or printed to stdout, what happens when output_path is null, or any prerequisites for generating policy definitions.

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

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

The description is a single sentence with no filler, front-loading the main action and target artifact. It is concise and efficient, though it sacrifices detail that other dimensions need.

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?

Even with full schema coverage, the description omits the output contract and the structure of the actions definitions. Without annotations or an output schema, an agent lacks essential information for invoking the tool correctly, such as where the generated XML goes and what format the actions array must follow.

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 100%, so the parameters already have individual descriptions. The tool description adds no extra semantic value, such as the expected structure of the actions JSON array or how vendor and vendor_url affect the generated policy.

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 ('Generate') and a clear resource ('standards-compliant .policy XML definitions for custom actions'). It clearly identifies the artifact produced, though it does not explicitly differentiate from sibling polkit tools like polkit_generate_rule.

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 usage guidance is provided. The description does not say when to use this tool versus polkit_generate_rule, polkit_list_actions, or polkit_pkexec, leaving the agent to infer selection from the name and artifact type.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether the tool writes a file to output_path, prints content to stdout, overwrites existing files, or requires any Polkit environment assumptions. 'Generate' implies creation but leaves the actual side effects and return behavior opaque.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to identifying the tool's purpose and output 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 no annotations and no output schema, the description is too sparse to be complete. It does not explain the behavior of output_path when null, what the generator returns, whether files are written, or how the rule content is constructed. An agent would still have to make risky assumptions about the tool's output and side effects.

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 100%, so the input schema fully documents all six parameters. The description adds no additional parameter-level context, which matches the baseline score of 3 for high schema coverage.

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

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

The description states a specific verb ('Generate') and a clear resource ('Polkit-1 JavaScript rule (.rules)') with an explicit purpose ('pre-authorizing specific actions'). It does not explicitly contrast itself with the sibling polkit_generate_policy, but the '.rules' format makes the target resource clear.

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

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

The phrase 'for pre-authorizing specific actions' implies the primary use case, but the description gives no guidance on when to choose this tool over polkit_generate_policy, polkit_check_auth, or other Polkit siblings. There are no exclusions or alternative-routing hints.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action ('list and search') but does not mention read-only nature, permission requirements, potential output size, or error behavior. The agent cannot infer safety or side-effects from the description 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 a single concise sentence with no filler. The action is front-loaded and immediately understandable, with no wasted words.

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 is simple with one optional parameter and no output schema. The description covers the basic action but does not mention the return format or any special behaviors like pagination or error handling. For a listing tool, this is mostly sufficient but leaves minor gaps that an agent might need to handle.

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

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

The single parameter filter_query is fully documented in the schema with 'Search term.' The description adds no extra meaning beyond the schema, but with 100% schema coverage, the baseline of 3 applies. The parameter is self-explanatory and the description does not need to compensate.

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 verb ('list and search') and a specific resource ('registered Polkit action definitions'). It is distinct from sibling polkit tools like polkit_check_auth, polkit_generate_policy, polkit_generate_rule, and polkit_pkexec, so an agent can easily differentiate it.

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 on when to use this tool versus the other polkit tools. The name and description imply it is for listing actions, but there is no mention of alternatives or conditions, such as 'use this to see available actions before checking authorization with polkit_check_auth.' The usage context is implied 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?

With no annotations, the description carries the full behavioral disclosure burden. It only mentions privilege escalation and pkexec, but does not disclose potential interactive authentication prompts, environment changes, side effects, failure modes, or output behavior. This is a privileged execution tool, so these missing details are significant.

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?

Single sentence with no filler, and the key differentiator ('elevated privileges') is front-loaded. Every word contributes to the definition.

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 privileged command-execution tool with no annotations and no output schema, the description is underspecified. It fails to address authentication behavior, security implications, command execution semantics, timeout behavior, or return values, leaving an agent without enough context to use it safely and correctly.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters including defaults. The description adds no additional parameter meaning beyond what the schema provides; baseline 3 is appropriate.

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

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

States a specific action ('Execute a command') with a clear qualifier ('with elevated privileges') and mechanism ('pkexec CLI escalation'). This distinguishes it from run_command and from other polkit_* tools that manage policies, rules, or authentication rather than executing 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?

No guidance on when to prefer this tool over run_command or other polkit tools. The elevated-privilege qualifier implies the use case, but there is no explicit when-to-use, when-not-to-use, or alternative-routing information.

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

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

With no annotations, the description carries the burden of indicating behavior. 'Get' clearly signals a read-only operation with no side effects, which is the main behavioral trait. Still, it does not explicitly state that it does not modify state or describe potential platform limitations or 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?

A single sentence that immediately states what the tool returns, with no filler, repetition, or irrelevant details. It is perfectly concise and well-structured.

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

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

For a parameterless read-only tool, the description fully specifies the output: load averages at three intervals plus core counts. There is no output schema, but the description fills that gap adequately. Nothing else is needed to select or invoke the tool correctly.

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

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

There are zero parameters and the schema is empty with 100% schema description coverage, so there is no parameter information missing. The description appropriately focuses on the output instead of parameters.

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

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

The description uses a specific verb ('Get'), names the exact resource (CPU load averages for 1, 5, and 15 minutes), and adds core counts as a second output. This clearly distinguishes it from sibling tools like process_get_priority or sensors_get_cpu_freqs.

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

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

The description implies when to use the tool: whenever load averages or CPU core counts are needed. However, it does not explicitly state when not to use it or mention alternatives such as sensors_get_cpu_freqs for frequency data, so the guidance is only 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?

No annotations are provided, so the description carries the full burden. It states the basic read operation but does not disclose potential errors (e.g., process not found, permission issues) or confirm it is non-destructive. For a simple getter this may be adequate, but it adds no behavioral context beyond the action itself.

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

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

A single, front-loaded sentence that states exactly what the tool does and the required input. There is zero waste, and the critical resource (nice priority level) is placed early.

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 read tool with a clear schema and no output schema, the description is largely sufficient. It could mention the return type (integer nice value) or failure behavior, but these are minor gaps given the low complexity. The description provides enough for an agent to call the tool correctly in most scenarios.

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

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

The input schema already describes the pid parameter with 100% coverage, and the description's mention of 'by PID' adds no new meaning. The schema does the heavy lifting, so the baseline of 3 applies; no additional parameter guidance is given.

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 ('Get'), a specific resource ('nice priority level of a running process'), and the key parameter (PID). It unambiguously distinguishes the operation from sibling tools like process_set_priority or process_kill, so an agent can select it correctly without opening the schema.

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

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

The description implies its use (to retrieve the nice value) but does not explicitly state when to prefer it over siblings or mention exclusions, such as 'use process_set_priority to change priority' or 'use process_list to find PIDs first.' The usage context is clear from the purpose, but no alternative routing is provided.

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

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

With no annotations, the description carries the full burden. It discloses the core behavior (signaling can terminate a process) but lacks details on permissions, error handling, or signal-specific consequences (e.g., SIGKILL cannot be caught). This is minimal but not misleading.

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

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

A single sentence that front-loads the action and target with zero wasted words. Every word 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 two-parameter tool with a fully documented schema and no output schema, the one-sentence description is nearly sufficient. It could mention the default signal or force-kill caveat, but the schema already declares SIGTERM as default, so the gap is 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?

Schema description coverage is 100%, so params (pid, signal) are already fully documented with types, defaults, and examples. The description adds no additional parameter semantics, which is acceptable per baseline.

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?

Description uses a specific verb ('send') and resource ('POSIX signal') targeting a process by PID. It clearly distinguishes this tool from siblings like process_list, process_set_priority, and run_command by stating exactly what it 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 usage: when a process needs to be signaled or terminated by PID. However, it provides no explicit alternatives, prerequisites, or when-not-to-use guidance compared to related process tools.

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

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

With no annotations, the description carries the burden of indicating side effects. The verb 'List' reasonably implies a read-only snapshot, and the description specifies the output fields. However, it does not state whether any permissions are needed, whether filtering is applied server-side, or whether the output is sorted or paginated.

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

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

A single, front-loaded sentence that names the action, the target, and the key output fields without any filler. Every word contributes.

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 list tool with one optional parameter and no output schema, the description covers the main return contents and the schema covers the filter. It lacks usage guidance and explicit side-effect disclosure, but the low complexity makes this a minor gap.

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

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

Schema coverage is 100%: the only parameter, 'filter', is described as an optional string for process name or command. The description adds no additional meaning beyond the schema, but the baseline of 3 applies because the schema already documents the parameter well.

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

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

The description clearly states the verb 'List' and the resource 'running system processes', and enumerates the returned fields (PID, CPU/memory usage, user, command line). It distinguishes itself from siblings like process_list_bg_jobs by focusing on running processes, though it does not explicitly name an alternative.

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

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

The description gives no guidance on when to use this tool versus siblings such as process_get_loadavg, process_get_priority, or process_list_bg_jobs. There is no mention of use cases, prerequisites, or exclusions.

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

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

The description implies a read-only operation ('list') but does not disclose any other behavioral traits such as return format, potential side effects, or whether it requires prior initialization of Textile. With no annotations, the description carries full burden and is insufficient for an agent to fully understand the tool's 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 a single, concise sentence with no unnecessary words. It clearly states the action (list), the resource (background jobs), and the specific scope (spawned and tracked by Textile) without any fluff.

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

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

While the description states the purpose, it lacks details about the output format or any side effects. For a read-only list operation with no parameters, this might be sufficient, but the absence of any mention of what the returned data looks like is a minor gap. The tool is simple enough that a 3 is reasonable.

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

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

There are zero parameters, so the schema is fully covered and the description needs no parameter explanation. The baseline of 4 applies because no parameters exist, and the description correctly avoids inventing 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 uses a specific verb 'List' and clearly identifies the resource as 'background jobs' with the context 'spawned and tracked by Textile'. This distinguishes it from sibling tools like process_list (which likely lists all processes) and process_get_state, making 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?

No guidance is provided on when to use this tool versus alternatives like process_list or process_get_state. It does not mention when not to use it, what prerequisites exist, or any conditions that would select this over other list-type 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates the mutation ('set') but does not mention required privileges, effect on the running process, reversibility, errors, or what happens on failure.

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

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

The description is a single, efficiently worded sentence with no filler. Every phrase is meaningful and the core action and scope are stated immediately.

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

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

For a simple two-parameter mutation tool with fully documented parametersoreschema, the description is largely sufficient to invoke the tool correctly. However, the lack of annotations and output schema means some behavioral context, such as permission requirements or return behavior, 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 input schema already describes both parameters with 100% coverage, including the priority range and default. The description restates the range and mentions 'by PID', but 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 action ('Set nice priority level'), the exact resource ('process by PID'), and the valid range (-20 to 19). This clearly distinguishes it from siblings like process_get_priority and process_kill.

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 or when to prefer an alternative such as process_get_priority. The intended use is only implied by the description and tool name, with no exclusions or context provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that a bash command is executed and implies a developer-task scope, but it does not disclose side effects, blocking behavior, output/exit-code semantics, working directory, or safety implications of running arbitrary shell commands.

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

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

The description is a single tight sentence with no filler. It front-loads the core action and adds a useful scope qualifier, making it appropriately sized for the tool's simplicity.

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 is simple and its two parameters are fully documented in the schema. However, there is no output schema, and the description does not mention what the command returns, whether it blocks by default, or how it should be preferred over sibling process/package tools, leaving some practical gaps.

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

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

Schema description coverage is 100%, so the input schema already documents 'command' and 'background' clearly. The description adds little parameter-level meaning beyond confirming bash usage and developer-focused intent, which matches the baseline for fully-covered schemas.

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 ('Execute'), a resource ('bash shell command'), and an intended scope ('developer tasks (git, tests, builds, package managers)'). It is clear enough to separate from file/process/package tools, though it does not explicitly name any sibling or contrast its behavior with 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 phrase 'for developer tasks (git, tests, builds, package managers)' provides a clear context for when to use this tool. It does not state exclusions or explicitly point to alternatives like packagekit_install or process_list, so it falls just short of full when/when-not guidance.

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

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

With no annotations provided, the description carries the full behavioral burden, but it only states the action without disclosing side effects, runtime expectations, whether the system is modified, or how results are delivered. This is a significant transparency gap for a tool that executes a full test suite.

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

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

The description is a single direct sentence with no wasted words. It front-loads the action and resource, and every phrase adds meaningful scope information.

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

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

For a zero-parameter trigger tool, an agent can understand what to invoke, but the description is the sole information source since there are no annotations or output schema. It omits expected return behavior, blocking/asynchronous nature, and potential side effects, leaving clear gaps for predicting the tool's outcome.

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

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

The tool has zero parameters, and the input schema already fully documents that with an empty object and additionalProperties: false. Parameter semantics are therefore complete by construction, so the description does not need to add parameter details.

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

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

The description uses a specific verb ('Run') and a precise resource ('the full Textile system diagnostic unit, integration, and E2E test suite'), clearly stating scope and test categories. It differentiates itself from the generic sibling 'run_command' by naming the exact Textile system suite it executes.

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 run_command, nor any mention of prerequisites or expected conditions. The name implies its use, but the description leaves the selection decision entirely to the agent.

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

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

There are no annotations, so the description carries the full behavioral burden. 'Live internet' conveys that the search is current and networked, but the description does not disclose the result format, result count, pagination, failure modes, or whether it is read-only. For a tool with no annotation support, this is thin.

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

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

A single, front-loaded sentence that wastes no words and communicates the tool's purpose immediately.

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

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

The tool is simple with one required parameter, so the description is adequate for constructing an invocation. But with no output schema and no annotations, it omits what the agent should expect in the response and how this relates to the sibling fetch_webpage.

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

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

Schema coverage is 100% and the query parameter is already described as 'Search query terms.' The description adds relevant examples of query intent (docs, code, versions, errors) but no format or syntax beyond what the schema provides, so it meets the baseline.

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 (search) on a specific resource (the live internet) and lists concrete content categories (documentation, code examples, API references, library versions, error solutions). It distinguishes itself from the mostly local/system sibling tools, though it does not explicitly contrast with fetch_webpage.

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 listed use cases imply when to use the tool: when the agent needs current web documentation or error fixes. However, it gives no explicit guidance on when not to use it or when fetch_webpage would be a better choice, leaving selection 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?

There are no annotations, so the description must convey behavioral safety itself; 'Retrieve live' indicates a read-only, current-data operation. However, it does not cover edge behavior such as offline cores, error conditions, or the exact output format.

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

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

One focused sentence with the core information front-loaded: action, subject, units, and scope. No filler, repetition, 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 parameterless read-only sensor tool with no output schema, the essential invocation information is present. It stops short of describing the exact return shape, but the simplicity of the tool makes that a minor gap.

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

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

The tool has zero parameters, so there is no parameter documentation burden to compensate for. The description adds useful units (MHz) and the data type (governors), meeting the baseline for a parameterless tool.

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

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

The description identifies a specific action ('Retrieve'), a concrete resource ('CPU core frequencies (MHz) and scaling governors'), and scope ('across CPU cores'). It is immediately distinguishable from the broader sibling sensors_get_telemetry.

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

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

No when-to-use or when-not-to-use guidance is provided, and no alternative tool is named even though sensors_get_telemetry could overlap. Intended usage is only implicit 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?

With no annotations, the description carries the full burden. It adds the mechanism ('via lm_sensors / sysfs') but does not disclose potential permission requirements, failure modes, or whether the returned data includes units or raw values. For a read operation, 'Retrieve' implies no mutation, but this is not explicit and no safety profile is provided.

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

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

The description is a single sentence that front-loads the primary action and resource, then adds a parenthetical list of sensor categories and the implementation source. Every word earns its place; there is no redundancy or padding.

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, parameterless tool, the description covers the key aspects: what it retrieves (telemetry types) and how it does so (lm_sensors / sysfs). The lack of an output schema is partially mitigated by listing returned categories, though units and data structure are not described. This is adequate for a simple read-only call but leaves minor ambiguity.

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 has zero parameters, so there is nothing for the description to explain. Per the baseline for 0-parameter tools, no compensation is needed; the description correctly omits parameter details.

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

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

The description uses a specific verb ('Retrieve') and clearly identifies the resource ('hardware telemetry') with concrete examples (temperatures, fans, voltages, power). It distinguishes itself from the sibling 'sensors_get_cpu_freqs' by explicitly excluding frequencies and focusing on other sensor categories, so an agent can select it correctly without opening 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?

No guidance is given on when to use this tool versus alternatives such as sensors_get_cpu_freqs or other process/read tools. The only cue is the tool's name and purpose, with no exclusions or conditions, so the agent must infer usage from 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?

With no annotations provided, the description carries the behavioral disclosure burden. 'Get' and the listed metrics clearly indicate a read-only query with no mutation. It does not discuss error cases or permission needs, but for a simple disk-usage lookup the description is sufficiently transparent.

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

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

The description is a single, well-structured sentence that immediately states the operation and the metrics returned. There is no filler, repetition, 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 simple tool with one optional parameter, the description plus schema is mostly complete. It identifies the return values conceptually and the schema handles the path definition. It could slightly improve by stating units or emphasizing that the path must be a mount/directory, but nothing critical is missing.

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

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

Schema coverage is 100%: the single 'path' parameter is already described as a 'Mount or directory path' with a default of '/'. The description's 'storage path' adds little beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and identifies the exact resource and metrics ('total, used, and available disk usage') for a storage path. This clearly distinguishes it from siblings like storage_list_mounts or file_stat, which have 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 gives no guidance on when to use this tool instead of alternatives, nor does it mention prerequisites, exclusions, or related tools. The intended use case is only implied by the tool name and 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?

No annotations are provided, so the description carries the full burden. 'List' implies a read-only operation, but it does not disclose output format, permissions required, or any side effects. For a tool with zero parameters, the description should at least hint at what data is returned (e.g., device names, mount points), but it does not.

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

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

The description is a single, efficient sentence with zero wasted words. It is front-loaded with the core action and resource, making it immediately scannable. This is ideal conciseness.

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

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

For a parameterless tool, the description is minimally adequate. However, since there is no output schema, the agent has no idea what the returned data will contain (e.g., mount points, device names, filesystem types). The description does not specify the output structure or any filtering options, leaving a moderate gap in completeness for a storage-listing 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?

With 0 parameters and 100% schema coverage (an empty schema), there is nothing to explain. The description adds no parameter details, but none are needed. Baseline 4 is appropriate because the schema is fully transparent and there are no parameters to compensate for.

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

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

The description clearly states the verb 'list' and the resource 'mounted filesystems and storage devices', which conveys the core purpose. It implicitly distinguishes from siblings like storage_disk_usage (which likely reports usage) and file_list (which lists files), though it does not explicitly name alternatives. It is specific enough for an agent to grasp the basic 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 description offers no guidance on when to use this tool versus alternatives such as storage_disk_usage or file_list. There are no conditions, prerequisites, or exclusions. An agent would have to infer usage from the name and schema, which is insufficient.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It implies a read-only operation via 'Get', but does not explicitly state side effects, permissions, or limitations. It is a minimal disclosure that does not contradict anything, but it also does not go beyond the obvious.

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

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

The description is a single concise sentence with no filler. It front-loads the action and resource, and the parenthetical clarifies the content. Every word 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 tool with no output schema, the description is sufficient. It states what the tool returns and its scope. It does not need to elaborate on return formats or side effects for such a simple getter. It could optionally mention that it is distinct from sensory state, but that is not a critical omission.

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

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

The tool has zero parameters, so the description adds no parameter-specific semantics. Since there is nothing to document, a baseline of 4 is appropriate—there is no gap to compensate.

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 ('Get') and a specific resource ('core engine execution state') and even clarifies the content ('active running tasks and execution history'). It is distinguishable from siblings like textile_get_sensory_state, though it does not explicitly name alternatives. It is clear but could be more explicit about what it is not.

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 like textile_get_state or textile_get_sensory_state. It does not state any conditions, prerequisites, or exclusions. An agent is left to infer usage context from the 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?

With no annotations provided, the description bears the burden of behavioral disclosure. It implies a read-only operation via 'get' and describes the snapshot as 'open', but does not explicitly state non-destructiveness, preconditions, or potential side effects. For a simple getter, this is minimally adequate but lacks richer context.

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

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

The description is a single, tightly worded sentence that leads with the action and resource. It includes a parenthetical that adds necessary specificity without fluff. No wasted words.

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

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

For a zero-parameter, no-output-schema getter, the description sufficiently conveys what the tool returns. It names the resource ('sensory state slots') and the content ('stitched notices/alerts'). It stops short of describing error conditions or runtime dependencies, but for its simplicity, it is reasonably 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 tool has zero parameters, and the schema coverage is trivially 100% (empty schema). With no parameters to document, the description has nothing to add. The baseline of 4 for zero-parameter tools is appropriate.

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

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

The description clearly states a specific verb ('Get') and resource ('open sensory blackboard snapshot') with a parenthetical detailing the contents. It distinguishes this tool from siblings like textile_get_engine_state and textile_get_state by specifying 'sensory' and the exact data it returns.

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 the sibling tools (e.g., textile_get_engine_state, textile_get_state). It only describes what it does, leaving the agent to infer usage context. Since there are clearly related getters, explicit differentiation or usage context is needed.

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

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

With no annotations, the description must carry behavioral disclosure, and 'Get' reasonably implies a non-mutating read. It adds the useful nuance that this is a 'full snapshot' of slots and notices, but it does not mention potential size, staleness, or any preconditions or side effects.

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

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

One succinct sentence with no filler; the key resource term 'full snapshot' is front-loaded and every word contributes.

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

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

For a zero-parameter read-only tool, the description is adequate: it names the resource and the returned scope. A slightly richer definition might explain what 'slots and notices' are or the snapshot format, but no output schema exists and the operational burden is low.

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 has no parameters, so schema coverage is trivially complete and the default baseline of 4 applies. The description does not need to clarify parameters; it only identifies the resource being returned.

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 the specific verb 'Get' and names a concrete resource ('full snapshot of the sensory blackboard state slots and notices'), so an agent knows what data is being returned. It does not explicitly contrast with the similar siblings textile_get_engine_state and textile_get_sensory_state, so it lacks 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 call this tool versus alternatives; the description only states the operation. 'Full snapshot' hints at use when complete state is needed, but no explicit context, exclusion, or alternative is provided.

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