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

With no annotations, the description carries the behavioral disclosure burden. It clearly explains the operation and the return value, but does not describe side effects or lack thereof, such as whether running units are left untouched or whether elevated privileges are required.

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

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

The description is short and front-loaded with the core action. The 'Returns' line adds a minor bit of redundancy given an output schema exists, but it is not wasteful enough to lower the score further.

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 an output schema, the description is mostly sufficient: it states what the tool does and what it returns. It falls short of being fully complete because it omits when-to-use context and any side-effect note, but an agent can still invoke it correctly.

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

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

The tool has zero parameters and the schema already documents this fully. There is nothing for the description to add, so the baseline score of 4 for a no-parameter tool 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 ('Reload') and resource ('systemd's unit file cache') and gives the canonical equivalent command, making the tool's purpose unambiguous. It also differentiates itself from sibling unit-focused tools by targeting systemd's daemon-level unit file cache rather than a single unit.

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 unit_reload_tool. It does not mention that it is appropriate after unit file changes, nor does it state any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. 'List' communicates a read-only query, and the return note specifies exactly what the agent gets: a list of failed units with a count. It does not mention side effects, but none are implied for a listing 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 extremely compact: one purpose sentence plus a short Returns block. Every element adds value, and the key scoping detail is front-loaded. There is 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 parameterless, read-only listing tool with an output schema, the description is complete. It names the resource, the filtering state, the operational trigger, and the return contents. An agent has everything it needs to select and invoke this tool correctly.

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

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

The tool has zero parameters, so the schema provides no parameter descriptions and none are needed. The description does not invent parameters or add irrelevant input guidance. Baseline 4 is appropriate 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 states a specific action and resource: 'List units currently in the failed state.' It clearly distinguishes this from sibling tools like unit_list_tool by scoping to failed units, and the 2AM note reinforces its narrow diagnostic 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 phrase 'first thing to check at 2AM' gives clear operational context for when this tool is appropriate: during quick incident triage. It does not explicitly name alternatives or say when not to use it, though the failed-state scoping implies it is the filtered counterpart to unit_list_tool.

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

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

There are no annotations, so the description carries the burden of signaling behavior. 'Get host identity info' clearly implies a read-only information retrieval operation with no mutation, which is adequate for a zero-parameter tool. It could be more explicit about side-effect absence, but the wording is sufficient.

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

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

The description is short and front-loaded, but the second line ('Returns: Hostname, kernel, and OS details') largely repeats the first sentence. This redundancy means not 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?

With zero parameters and an existing output schema, this description is complete for selecting and invoking the tool. It names the resource and the three pieces of returned identity information, and the output schema can cover the return structure.

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 baseline is 4. The description correctly does not attempt to explain parameters that do not exist, and the empty schema already fully covers the parameter surface.

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') with a clear resource ('host identity info') and enumerates the exact fields returned: hostname, kernel, and OS. This clearly distinguishes it from the sibling unit, journal, and timer tools.

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

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

No guidance is given on when to use this tool versus alternatives. It is implicitly the only host-identity tool among the siblings, but the description does not state any context, prerequisites, or scenarios where it should or should not be used.

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

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

With no annotations, the description must carry the behavioral burden; 'Query' and 'journal' indicate a read-only log inspection, which is a key behavioral trait. However, it says nothing about permissions, output size, or runtime implications, so the disclosure 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?

The description is a single concise sentence with no filler, front-loading the core purpose. The '2AM' quirk adds a tone of urgency but is not strictly necessary.

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 rich schema and presence of an output schema cover parameters and return values, leaving the description with little to explain. Still, a note about when this tool is the right choice among the many sibling tools would make the definition more 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%, so all seven parameters are already documented with defaults and examples. The description adds no parameter-level meaning, so the baseline 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?

'Query the journal' is a specific verb and resource that conveys exactly what the tool does. It is implicitly distinguished from sibling unit-management tools by its focus on journal logs, though it does not explicitly name any 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 phrase 'the main 2AM troubleshooting tool' implies it is intended for diagnosing problems, but gives no explicit when-to-use or when-not-to-use conditions and does not compare it to sibling status/unit tools.

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

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

With no annotations provided, the description carries the full transparency burden. It clearly indicates a read-only listing operation and even mentions the return shape: "List of pending jobs with count". It does not over-describe side effects, which is appropriate for a list 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 two concise sentences with no filler. The primary action and purpose are front-loaded, and the return information is compactly stated.

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

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

For a zero-parameter, read-only list tool with an output schema available, the description covers the action, the diagnostic value, and the return format. Nothing essential for calling the tool correctly is missing.

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

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

The tool has zero parameters, so there are no parameter semantics to clarify. The baseline for zero-parameter tools is 4, and the description appropriately does not attempt to invent parameter guidance.

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

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

The description states a specific verb and resource: "List pending systemd jobs", which clearly identifies what the tool does. The phrase "reveals stuck starts/stops/reloads" adds useful diagnostic context and differentiates it from siblings like unit_list_tool or timer_list_tool, which list different systemd entities.

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

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

The description implies when to use the tool: when you want to see pending systemd jobs, especially to spot stuck starts/stops/reloads. It gives clear context but does not explicitly contrast with alternatives or state when not to use it, stopping short of a 5.

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

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

No annotations are provided, so the description carries the behavioral transparency burden. The verb 'List' clearly indicates a read-only operation, and 'who's on this box right now' signals a live/snapshot behavior. It also discloses the return shape ('List of sessions with count'), which is sufficient for a simple listing tool.

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

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

The description is two short, front-loaded parts: a plain-language purpose and a compact return contract. Every line contributes useful information without redundancy, making it easy for the agent to parse quickly.

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

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

For a zero-parameter listing tool with an output schema already present, the description is complete enough. It states what the tool listsainer, conveys 'right now' current-state semantics, and explicitly mentions the count in the return value. No additional behavioral or usage information is needed for correct invocation.

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

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

The tool has zero parameters and the input schema is empty, so the description cannot add parameter-level meaning. Per the baseline for 0-parameter tools, this is appropriately complete; there is nothing about parameters the agent needs to know.

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

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

The description states a specific verb and resource: 'List logged-in sessions' and clarifies scope with 'who's on this box right now.' This clearly distinguishes it from the sibling unit and system tools, which target services, host info, or system status.

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

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

The description provides clear context for when to use the tool: when the agent needs to know currently logged-in sessions on the host. It does not explicitly name alternatives or exclusions, but given the sibling list, no competing session-listing tool exists, so the usage context is unambiguous.

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 burden of conveying safety and side effects. 'Get' clearly signals a read-only operation, and the return field list gives concrete behavioral context about what the tool surfaces. It does not explicitly state 'does not modify system state', but the read-only semantics are evident from the wording.

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 compact two-part statement: the purpose is front-loaded, and the return fields are listed in a clean second line. There is no redundant filler or restating of 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?

For a zero-parameter read-only status tool with an output schema, the description is sufficiently complete. It conveys what the tool returns and the scope of the query. It could have mentioned that detailed failed units and jobs live in sibling tools, but the overall system-state framing already implies that distinction.

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 zero parameters and 100% schema coverage, so there is nothing for the description to add about parameter meaning. The baseline of 4 applies because no parameters exist and no clarification is needed.

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: 'Get overall systemd manager state'. It also lists the key output dimensions (running/degraded, failed and job counts), which clearly distinguishes it from the unit-specific sibling tools.

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

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

The phrase 'overall systemd manager state' provides clear context that this tool is for system-wide status rather than per-unit operations. It does not explicitly name sibling alternatives or when not to use them, but the scope is unambiguous enough for an agent to choose correctly.

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 clearly indicates a read-only listing operation and states the return shape ('List of timers with count'). It does not mention subtle behaviors like filtering or status handling, but for a simple list tool this is largely sufficient.

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

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

The description is extremely concise, front-loads the action and resource, and adds a returns section without unnecessary filler. 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 parameterless listing tool, the description covers the operation and the high-level return contents. The presence of an output schema means detailed return fields need not be enumerated in the description. The tool is simple enough that nothing essential 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 tool has zero parameters, so the schema already fully covers parameter semantics. The description adds no parameter details, but none are needed; baseline 4 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 action ('List systemd timers') and the key output fields ('next and last elapse times'). It is clearly distinct from sibling tools like unit_list_tool, which covers all units rather than timers specifically.

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 about when to use this tool versus alternatives such as unit_list_tool or system_status_tool. The only usage signal is implied by the resource name 'systemd timers,' but there is no when-to-use or 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 the full behavioral burden. It does disclose the useful constraint 'Refused for units on the protected list' and clarifies that the operation affects boot behavior, not current runtime state. However, it omits other important traits such as permission requirements, idempotency, and effect on an already-running unit.

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

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

Two short sentences with no filler. The core action is front-loaded, and the protected-list restriction earns its place as a direct, important constraint. Nothing extraneous is included.

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 tool with an output schema, the description is mostly sufficient: it identifies the operation, the target, and a key refusal condition. But it lacks any guidance about alternatives and does not disclose the broader behavioral consequences of disabling a unit, which matters more because there are no annotations to fill the gap.

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

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

Schema description coverage is 100%: the only parameter, unit_name, is documented as 'Systemd unit name.' The description adds no additional parameter-level meaning, but none is needed given the simple schema and the tool's clear purpose.

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

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

The description states a specific action and resource: 'Disable a unit from starting on boot.' This clearly separates boot-time disabling from runtime stop/start operations and identifies the tool's core function. The added protected-list refusal further clarifies scope.

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

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

There is no explicit guidance on when to use this tool versus siblings like unit_mask_tool, unit_stop_tool, or unit_enable_tool. The protected-list note implies one exclusion, but it does not say what to do instead or under what conditions the tool should be chosen.

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 behavioral disclosure burden. It states the core effect (configuring boot-time startup) but does not mention side effects like modifying systemd configuration, permission requirements, or that enabling does not start the unit immediately.

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 conveys the tool's purpose with no filler or redundancy. It is front-loaded and easy for an agent to parse quickly.

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

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

With one required parameter and an output schema, the description plus schema form a minimally adequate contract for making the call. However, it lacks context about side effects, permissions, and the distinction from immediately starting a unit, which could lead to misuse for an immediate-start request.

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 the schema already documents the single unit_name parameter. The description adds no additional parameter-level meaning, such as accepted unit name formats or whether the '.service' suffix is required, but 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 names a specific operation ('Enable'), a resource ('a unit'), and the intent ('to start on boot'), which is unambiguous. It clearly distinguishes itself from siblings like unit_start_tool (immediate start) and unit_disable_tool (reverse operation).

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

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

The boot-time context implies when to use the tool, but there is no explicit guidance on when not to use it or which sibling to prefer. It leaves routing decisions to inference rather than naming alternatives 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so thoroughly. It reveals the full side-effect chain (stop, disable, optionally mask, back up, remove file), calls out refusal for protected units, and explains best-effort semantics for stop/disable, including that already-stopped or never-enabled units do not block removal. This is exactly the kind of behavioral transparency an agent needs for a destructive 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 two tight sentences with no filler. The first sentence front-loads the tool's core purpose and full operation; the second adds essential caveats about protected units and best-effort behavior. Every clause 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?

Given that an output schema exists and the input schema covers parameters, the description is nearly complete for correct invocation: it states what the tool does, its edge-case behavior, and a refusal condition. It could go slightly further by noting whether a daemon reload is needed after file removal or recommending a sibling tool for non-destructive changes, but those are refinements rather than critical omissions.

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 fully documents both parameters. The description adds no new parameter-level meaning beyond reiterating that masking is optional, which the schema already declares with a default of false. Baseline 3 is appropriate because the schema is doing 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?

The description opens with a clear verb-resource pair: 'Decommission a unit' and then enumerates the concrete operations: stop, disable, optionally mask, back up, and remove its file. This unambiguously distinguishes the tool from siblings like unit_stop_tool, unit_disable_tool, or unit_mask_tool because only this tool removes the unit file as part of 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 the intended use case ('decommission a unit') and states a clear exclusion ('Refused for units on the protected list'), but it never explicitly contrasts this tool with sibling tools for lighter operations such as simple stop, disable, or mask. An agent must infer that those lighter actions belong on the sibling tools rather than being told directly.

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

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

With no annotations, the description carries the behavioral disclosure burden. It transparently states two significant side effects: it backs up any overwritten file and runs daemon-reload after writing. It also discloses an environmental requirement. This is strong transparency for a write 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 two concise sentences with no filler. Each sentence earns its place: the first states the action and a key side effect, the second covers the prerequisite and post-write behavior. Information is front-loaded and easy to parse.

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

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

Given the tool's moderate complexity and the presence of an output schema, the description covers the essential operational context: what it does, the bind-mount prerequisite, backup behavior, and daemon-reload side effect. It does not detail failure modes or permissions, but it provides enough for an agent to select and invoke the tool appropriately.

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 unit_name, content, start, and enable. The description does not add new meaning beyond the schema, but it does frame content as the full unit file contents and implies these parameters are for service setup. This meets the baseline but adds little extra.

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 a new unit file for setting up a service.' It clearly indicates the tool's role and even hints that it may overwrite existing files (via backup). It does not explicitly contrast with sibling tools like unit_file_remove_tool, but the function is unambiguous from name and text.

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 a clear prerequisite—host unit directory must be bind-mounted—and notes that daemon-reload is run afterwards. However, it does not explicitly state when to choose this tool over siblings such as unit_file_remove_tool or unit_start_tool, leaving usage boundaries mostly implied by the 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, but the description does not explicitly state that it is non-destructive, nor does it mention that by default it only shows active/failed units (as indicated in the schema). Without any statement about side effects or limitations, the behavioral profile is under-disclosed.

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

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

The description is a single short sentence, which is efficient, but it essentially restates the tool name (unit_list_tool) and provides no additional context. It is not verbose, but it also does not earn its place by adding insight beyond the name. A slightly more informative sentence could have covered default behavior or scoping without sacrificing 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 the full input schema and presence of an output schema, an agent can technically call the tool correctly. However, the lack of annotations means the description should compensate with behavioral and usage context, which it fails to do. The description is adequate for a simple list tool but incomplete for an agent that needs to decide when to use it or what side effects to expect.

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 coverage is 100%, so each parameter (mode, pattern, all_units) already has detailed descriptions. The description itself adds no information about how these parameters interact or what values to supply, which is acceptable given the schema carries the load. This matches the baseline 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 clearly states the verb 'List' and the resource 'systemd units', making the basic purpose explicit. However, it does not differentiate from sibling tools like failed_units_tool or timer_list_tool, which also list subsets of units. The absence of any mention of filtering modes or patterns means an agent cannot tell this apart from similar list tools 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention that mode='loaded' vs 'files' selects different scopes, nor that pattern and all_units control filtering. While the schema provides parameter descriptions, the description itself offers no usage context or exclusions, leaving the agent to infer usage solely from parameter names.

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

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

No annotations are present, so the description carries the behavioral burden. It discloses the key mutating effect ('cannot be started even manually') and a notable exception ('Refused for protected units'). It does not mention reversibility via unmask, but the core behavior is clearly exposed.

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

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

Two short sentences with no filler. The main effect is front-loaded and the exception is stated efficiently, making every sentence valuable.

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

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

For a simple single-parameter tool with an output schema, the description is largely complete: it states the action, the consequence, and a protective refusal case. It could add a mention of undoability via unmask, but nothing critical is missing for invoking it correctly.

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

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

The input schema covers 100% of the single parameter with 'Systemd unit name', so the schema already documents what is needed. The description does not add extra meaning beyond that, matching the baseline 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 uses a specific verb ('Mask') and names the resource ('a unit'), and clearly states the effect: the unit cannot be started even manually. This distinguishes it from related operations like enable, disable, and unmask.

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 situations where even manual starts must be blocked, which hints at when it should be preferred over disable. However, it does not explicitly name alternatives or state when not to use it, leaving some inference 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?

With no annotations, the description carries the burden of behavioral disclosure. It correctly highlights the key behavioral trait (no restart), which is the most important distinction. However, it omits potential side effects (e.g., reload may not be supported by all units, configuration might fail silently, or reload requires the unit to be active). This leaves some gaps, but the core behavior is 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?

A single, front-loaded sentence that states the verb and resource immediately and adds the key qualifier ('without restarting') with zero filler. 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?

Given the low complexity (one parameter), full schema coverage, and presence of an output schema, the description is sufficient. It clearly states the tool's purpose and differentiates it from restart, which is the main contextual need. It doesn't address edge cases like units that don't support reload, but this is a minor omission given the 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 description coverage is 100%, so the parameter is fully described in the input schema. The description adds no additional meaning 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 clearly states the action (reload) and the resource (unit configuration), and explicitly differentiates from restart with 'without restarting,' making the intent unambiguous and distinguishing it from sibling tools like unit_restart_tool.

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

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

The description implies when to use the tool: when you want to apply configuration changes without a full restart. This provides clear context and effectively distinguishes from restart, though it doesn't explicitly name alternatives or state when not to use it. The implied contrast is sufficient for most agents.

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

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

With no annotations, the description carries the behavioral burden. It does disclose a notable behavior: refusal for protected units. However, it omits other relevant behaviors such as potential downtime, permission requirements, or what happens if the unit is not running.

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

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

Two short sentences with no filler. The core action is front-loaded and the protected-list restriction is stated efficiently. Nothing here wastes the agent's attention.

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 an output schema exists, but the description leaves the 'protected list' undefined and does not explain how an agent can determine whether a given unit is protected. Without annotations or additional context, this is a meaningful gap, though not crippling for a one-parameter action.

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 unit_name is already fully described in the schema as 'Systemd unit name' (100% coverage). The tool description adds no additional semantics about format, valid values, or naming conventions, so 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 uses a specific verb and resource ('Restart a unit'), which is immediately clear and distinct from sibling operations like start, stop, or reload. The refusal clause adds an important boundary without obscuring the core 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?

No guidance is given for when to use restart versus the closely related sibling tools such as unit_start_tool, unit_stop_tool, or unit_reload_tool. The protected-list refusal is a constraint, but it does not help an agent choose between alternatives.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It states the tool dumps the full property set, which implies a read-only operation, but it does not disclose output size, potential verbosity, or whether it requires privileges. The description adds some context beyond the schema but lacks depth.

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 action and resource. It is efficient and free of fluff, though it could benefit from a brief note on when to use it.

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 simple input schema and an output schema, so the description need not explain return values. However, given the large sibling set, the description could be more complete by clarifying how this differs from unit_status_tool or unit_list_tool. The core purpose is clear, but the context is slightly incomplete.

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 parameter (unit_name). The description does not add extra meaning about the parameter beyond what the schema provides, so a 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 uses a specific verb ('Dump') and resource ('full property set for a unit'), and lists example property categories (dependencies, exec settings, cgroup). It is clear what the tool does, though it does not explicitly distinguish it from sibling tools like unit_status_tool or unit_list_tool.

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

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

The description implies this is for inspecting a unit's full property set, which suggests a diagnostic use case, but it does not explicitly state when to use this tool versus alternatives like unit_status_tool or journal_query_tool. No exclusions or alternative routing are provided.

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

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

With no annotations, the description must fully disclose behavior. 'Start a unit' only states the action but doesn't disclose side effects, error conditions, or whether the operation is reversible. It doesn't mention what happens if the unit is already started or what state changes occur. This is minimal and leaves critical behavioral details unaddressed, warranting a 2.

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

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

The description is extremely concise (one sentence) and front-loaded, but it under-specifies. While brevity is good, it sacrifices necessary context. It is not verbose, but it also doesn't add enough value beyond the tool name, so a middle score of 3 is fair.

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 presence of many sibling tools and the absence of annotations or output schema details, the description is insufficient. It doesn't explain when to use this over similar tools, nor what constitutes success or failure. The operation is simple, but with no guidance an agent might misuse it. It is not complete enough for effective tool selection.

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 provides 100% coverage with 'Systemd unit name' for the single parameter. The description adds no additional semantic meaning beyond the schema. Since schema already documents the parameter well, the baseline of 3 applies without any extra insight from the description.

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

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

The description 'Start a unit' clearly specifies the verb (start) and the resource (unit). It is unambiguous about what it does, though it does not explicitly differentiate itself from sibling tools like unit_stop_tool or unit_restart_tool. It is a clear statement, so 4 is appropriate.

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 many alternatives (stop, restart, reload, etc.). It doesn't mention prerequisites, such as whether the unit must already be defined or enabled. Without any context or alternative comparisons, an agent receives no usage direction, so score is 2.

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. 'Get' implies a read-only action and 'curated' indicates that the output is a processed summary rather than raw status, but it does not explicitly note absence of side effects, permission needs, or behavior when the unit does not exist.

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 immediately names the action and resource, then lists the exact status fields. There is no filler or redundant repetition of schema 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 one-parameter status tool with an output schema present, the description is largely sufficient: it names the target unit type and the fields returned. A slight gap is the lack of guidance about how this curated status differs from more detailed sibling tools, but the output schema covers return-value expectations.

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 parameter unit_name already has a clear description and example. The tool description adds no additional parameter semantics, 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 states a specific verb ('Get'), a specific resource ('status for a unit'), and enumerates the key status fields (active/sub/load state, PID, memory, CPU). The word 'curated' and the field list distinguish it from sibling tools like unit_show_tool or unit_list_tool.

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

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

The description explains what the tool does but gives no guidance on when to choose it over alternatives such as unit_show_tool, unit_list_tool, or system_status_tool. It does not state exclusions, prerequisites, or preferred contexts.

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 add a meaningful behavioral detail by stating 'Refused for units on the protected list,' but it does not mention failure modes, permission requirements, or side effects beyond the obvious 'stop' action. This is helpful but not comprehensive.

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

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

The description is two short sentences with no redundant phrasing. The core action is front-loaded, and the protected-list guardrail is a necessary caveat rather than filler.

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

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

For a one-parameter lifecycle tool with an output schema, the description is mostly complete: it states what the tool does and flags an important constraint. The only notable gap is the lack of explicit guidance about when to prefer sibling tools, which is a minor omission for such a straightforward operation.

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

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

The input schema covers 100% of the parameters, and the unit_name field is already described as 'Systemd unit name.' The description does not need to add parameter details; it neither contradicts nor enriches the schema, so 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 ('Stop') and resource ('a unit'), which clearly distinguishes it from sibling tools like unit_start_tool, unit_restart_tool, and unit_reload_tool. Even without mentioning 'systemd' explicitly, the schema's 'unit_name' makes the target 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 main purpose is self-evident for a stop operation, and the note about protected units implies a restriction. However, it does not explicitly clarify when to use this tool instead of related lifecycle tools (e.g., unit_disable_tool for preventing startup at boot, or unit_mask_tool for stronger disabling).

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 provided, so the description carries the full burden. It only states the operation type without disclosing the effect (e.g., whether it requires root privileges, whether it changes system state permanently, or what happens if the unit is not currently masked). No mention of side effects or prerequisites.

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 without fluff. However, the description is so brief that it borders on under-specification; it could be expanded to include behavioral context while still being 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?

Given that this tool performs a system mutation (unmasking a unit), the description should cover prerequisites, error conditions, and the effect on the system. It is a state-changing operation with potential security implications, and without annotations or explanation, the description is incomplete.

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 is already documented as 'Systemd unit name'. The description adds no additional semantic detail beyond the operation itself, and since there is only one required parameter with full coverage, the 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 a specific verb ('Unmask') and resource ('a previously masked unit'), making it obvious this tool reverses the action of unit_mask_tool. It is distinct from siblings like unit_enable_tool and unit_start_tool.

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

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

No explicit guidance on when to use this tool versus alternatives, such as when a unit is masked and needs to be re-enabled for use. Context is very thin, relying on the description to imply it's the counterpart to masking, but no exclusions or alternatives are mentioned.

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