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 clarifies the core action and return value, but doesn't mention potential side effects, whether it affects running units, or whether elevated privileges are required. Useful but incomplete.

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

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

The description is compact and front-loaded, with the core action in the first sentence. The return note is minimal and the whole definition has no fluff or redundant elaboration.

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-annotation tool with an output schema, the description is complete enough for correct selection and invocation. The systemctl equivalence provides additional real-world context that makes the tool self-contained.

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 accepts zero parameters, so there is nothing for the description to clarify. The baseline of 4 for no-parameter tools is appropriate 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 states a specific verb and resource: 'Reload systemd's unit file cache', and anchors it with the well-known equivalence 'systemctl daemon-reload'. This makes the tool's scope clear and distinguishes it from sibling unit-level tools like unit_reload_tool, even without naming 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?

No guidance is given about when to use this tool versus alternatives. It doesn't mention the common use case of running it after unit files are added, modified, or removed, nor does it contrast with unit_reload_tool or unit_* management 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. It clearly indicates a read-only list operation and describes the return value ('List of failed units with count'). However, it does not mention edge cases such as an empty result set, error behavior, or system impact, though 'List' strongly implies no 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?

The description is two short sentences with no wasted words. The core purpose is front-loaded, and the return information is clearly separated.

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

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

For a zero-parameter read-only listing tool, the description is complete: it states what is listed, the filtering criterion, and the expected return shape. An output schema exists, so deeper return details are already structured.

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 an empty object, so there are no parameter semantics to document. The baseline of 4 applies because no additional parameter explanation 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 states a specific verb ('List'), resource ('units'), and a clear filter ('currently in the failed state'). This distinguishes it from sibling tools like unit_list_tool, which would list all units, and unit_status_tool, which is for a specific 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 phrase 'the first thing to check at 2AM' gives clear diagnostic context for when this tool is appropriate. It does not explicitly name alternatives or exclusion conditions, but the intended use case is evident.

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 states that the tool returns hostname, kernel, and OS details, which is sufficient for a simple no-argument read-only info tool. It does not mention execution context or potential errors, but the domain is low-risk and well-specified.

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 appropriately short and front-loaded with the core purpose. The second line ('Returns: Hostname, kernel, and OS details') largely repeats the first sentence, adding minor redundant weight but no significant harm.

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

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

For a no-parameter hostinfo tool with an output schema available, the description is complete: it names the data scope and the returned concepts. An agent has everything necessary to decide whether to invoke it and to understand what it will get back.

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 schema coverage is 100%, so the description has no parameter semantics to explain. The baseline for zero-parameter tools applies, and the description adds no conflicting or missing param 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 uses a clear verb-resource pair ('Get host identity info') and specifies the exact fields (hostname, kernel, OS). This cleanly separates it from sibling tools that target units, jobs, timers, or sessions.

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

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

The description clearly establishes when to use the tool: whenever host-level identity details are needed. It does not mention alternatives or exclusions, but the context is unambiguous enough that no alternative tool could be confused with it.

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

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

There are no annotations, so the description carries the full behavioral burden. It only says 'Query' and does not explicitly state that this is a read-only operation, whether it can scan the whole system journal, or any resource/impact caveats. This is a notable gap for a diagnostic 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 short sentence with the core action front-loaded. The '2AM' phrasing is informal but compact and quickly conveys the troubleshooting role.

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?

Parameter syntax and return shape are fully covered by the input and output schemas. The remaining gap is that the description does not provide behavioral guardrails or read-only assurance, which matters because there are 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?

Input schema coverage is 100% with each of the 7 optional parameters having a type, default, and description. The description adds no parameter-level detail, but none is needed; the 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?

The description states a specific action and resource: 'Query the journal', and identifies it as the main troubleshooting tool. None of the sibling tools query logs, so an agent can immediately distinguish this from unit/job operations.

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 2AM troubleshooting tool' gives a clear context: use it when diagnosing problems via logs. It does not name exclusions or alternatives, but no other journal/log sibling exists, so the guidance is adequate.

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. 'List' clearly signals a read-only operation, and the stated return ('List of pending jobs with count') tells the agent what to expect. It does not mention privilege requirements or edge cases, but for a zero-parameter list tool this is adequate.

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 that front-load the core action and purpose, then state the return value. There is no redundant wording or unnecessary repetition 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 simple zero-parameter tool with an output schema, the description covers the purpose and return shape sufficiently. It could clarify what counts as 'pending' or how the count is computed, but these are minor gaps and do not hinder correct usage.

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

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

The tool takes no parameters and the input schema fully documents this. With 0 parameters, the description is not required to explain parameter semantics, and it appropriately avoids inventing any.

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'. It also adds a meaningful purpose ('reveals stuck starts/stops/reloads') that distinguishes it from sibling tools focused on unit state or journal queries.

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 'reveals stuck starts/stops/reloads' implies when an agent might want this tool, but there is no explicit comparison with sibling tools like failed_units_tool or system_status_tool, nor any when-not-to-use guidance. Usage context is present but 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 behavioral burden. 'List' clearly signals a read-only inspection operation, and the stated return of 'List of sessions with count' discloses the observable output. It does not mention permissions or side effects, but for a zero-parameter list operation the risk is low.

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

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

The description is two short sentences with no filler. The purpose is front-loaded and the return shape is stated separately, making it easy for an agent to scan and apply.

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, zero-parameter tool with an output schema, the description provides the essential purpose and return structure. A slightly more explicit note about what counts as a session would remove ambiguity, but the core information is sufficiently 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 no parameters, and the schema explicitly encodes that with 100% coverage. There is nothing for the description to add about parameter meaning, so the baseline of 4 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: 'List logged-in sessions' immediately identifies the tool's function. The phrase 'who's on this box right now' makes the purpose concrete and distinguishes it from the unit/status management 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?

The description gives clear context for when to use the tool: when you need to see current logged-in sessions. It does not explicitly name alternatives or state when not to use it, but the resource focus is distinct enough among siblings.

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

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

No annotations are provided, so the description carries the full burden. It clearly indicates a read operation via 'Get' and lists the returned fields, which is useful. But it does not explicitly state that the operation has no side effects on the system, nor does it mention any privilege requirements or rate limits. Adequate but not deeply 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 two terse sentences with the core purpose front-loaded and no filler. Every part contributes: what the tool does and what data it returns.

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 status query with an output schema, the description is largely complete: it states the scope and names the returned fields. It could offer more context about interpreting the returned values, but the output schema likely covers those details, so 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?

The tool has zero parameters and the schema already reflects this with 100% coverage. There is no parameter meaning for the description to add, so the baseline of 4 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 states a specific action ('Get') and resource ('overall systemd manager state'), and it enumerates what is captured: running/degraded state, failed units, and job counts. The word 'overall' clearly sets it apart from unit-scoped siblings such as unit_status_tool, even though it does not name them explicitly.

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: for overall manager state rather than unit-specific operations. However, it gives no explicit when-not-to-use guidance and does not mention related alternatives like failed_units_tool or list_jobs_tool for more detailed views. Usage context 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 provided, so the description carries the burden of behavioral disclosure. It does indicate a read-only listing operation and the return shape (list with count), but it does not mention privilege requirements or whether inactive timers are included. These omissions are not misleading for such 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 short and front-loaded with the core action. The 'Returns:' line adds a small amount of detail but is slightly redundant with the first sentence. Overall, it is concise and purposeful.

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 with an output schema, the description adequately defines what the tool does and what it returns. It does not specify timer state filtering or sorting, but those details are not required given the simple scope and available output schema.

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

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

There are zero parameters, so the description has no parameter semantics to add. The baseline of 4 applies because there are no arguments that could be ambiguous or need clarification.

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 concrete resource ('systemd timers') and details the key returned data ('next and last elapse times'). This clearly differentiates it from sibling unit/status tools by focusing on the timer resource.

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 tool is for listing systemd timers and their elapse times, but it does not explicitly state when to prefer it over unit_list_tool or other sibling tools. No exclusions, prerequisites, or alternative routing guidance is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add the useful side-effect that operations on protected units are refused. However, it omits other common behavioral traits, such as whether a currently running unit is unaffected, whether root privileges are required, or whether the operation is reversible via enable. The protected-list disclosure earns a pass, but the description could be more 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 two sentences with zero filler. The core action is stated first, and the protected-list exception is appended as a necessary behavioral note. Every sentence contributes; this is an example of appropriately concise and well-structured text.

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

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

For a single-parameter tool with an output schema, the description is largely adequate: it states what the tool does and the key exception. However, it does not mention that disabling a unit does not stop it if it is currently running, which is a common misunderstanding and could lead to incorrect tool selection. Given the low complexity, the description is functional but not fully complete for an agent unfamiliar with systemd.

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 is documented as 'Systemd unit name'), so the description adds no extra semantics. That is acceptable per the baseline rule, though the description does not clarify whether the unit name should include the .service suffix or other common format 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 'Disable a unit from starting on boot' clearly states the specific action (disable) and resource (unit) and scope (at boot), which distinguishes it from tools like unit_start_tool or unit_stop_tool. It does not explicitly contrast with unit_mask_tool or unit_enable_tool, but the boot-time focus is enough to make the primary 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 given on when to choose this tool over siblings such as unit_mask_tool, unit_stop_tool, or unit_enable_tool. The only additional sentence mentions a refusal condition (protected list) but does not help an agent decide between alternatives. This is a clear gap for a tool with many closely related siblings.

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

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

No annotations are provided, so the description carries the full burden. It merely states the intended effect ('start on boot') but does not disclose what enabling actually changes (e.g., creating symlinks in systemd), whether the operation is idempotent, whether root privileges are required, or what happens if the unit is already enabled. For a mutation tool, this is a significant transparency 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 short sentence with no filler. It is appropriately front-loaded and every word earns its place. The lack of extra sentences does not hurt conciseness, though other dimensions penalize the missing content.

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

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

Given the tool has one fully documented parameter and no annotations, the description is overly minimal. It omits behavioral details, prerequisites, and any relationship to the many sibling systemd tools. The presence of an output schema does not compensate for missing usage guidance and behavioral transparency. A complete definition for this mutation tool should mention idempotency, persistence, and how it differs from starting a unit immediately.

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%: 'unit_name' is documented as 'Systemd unit name'. The description adds no additional parameter meaning beyond what the schema provides, so the baseline of 3 applies. No further enrichment is necessary.

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+resource: 'Enable a unit to start on boot.' This distinguishes it from siblings like unit_start_tool (immediate start) and unit_disable_tool (disable boot start). It is specific but does not explicitly name the sibling distinctions, so it does not earn a 5.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of when enabling is appropriate, no exclusions, and no reference to related tools such as unit_start_tool for immediate start or unit_disable_tool for reverting. The agent is left to infer usage context 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?

With no annotations, the description carries the full burden and does well: it discloses the multi-step destructive behavior, backup, optional masking, protected-list refusal, and best-effort semantics for stop/disable. It does not mention permission requirements or what 'back up' entails, which would strengthen transparency for a destructive operation, but it is far above the minimum.

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 sentences with no fluff. The main action is front-loaded, and the caveats (protected list, best-effort behavior) are placed immediately after. Each sentence earns its place and there is no redundant restatement of the title or schema.

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

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

For a destructive multi-step tool, the description covers the essential context: what will happen, when it will be refused, and when partial failures do not block removal. An output schema is present, so return values need not be described. A bit more detail about backup location or required privileges would make it fully complete for an agent, but the current description 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%, so the baseline is 3. The description's 'optionally mask' matches the mask parameter and 'remove its file' maps to unit_name, but it adds little meaning beyond what the schema already explains. No extra parameter-level guidance is provided.

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

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

The description opens with a specific verb and resource: 'Decommission a unit', then lists the exact operations (stop, disable, optionally mask, back up, remove file). This clearly distinguishes the tool from siblings like unit_stop_tool, unit_disable_tool, and unit_mask_tool by marking it as the full removal/decommission operation. It also adds a scope constraint (protected-list refusal) that makes the tool's purpose more precise.

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

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

The description gives a clear when-to-use signal: decommissioning a unit, as opposed to merely stopping or disabling it. It also states an explicit when-not: 'Refused for units on the protected list.' However, it does not explicitly name alternative sibling tools such as unit_stop_tool for stop-only scenarios, so it stops just short of the highest level of 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?

With no annotations, the description carries the full behavioral burden. It discloses that the tool overwrites files with a backup and runs daemon-reload after writing, which are critical side effects. It does not describe error cases or permission requirements, but the disclosed behaviors are the most important for safe invocation.

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

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

The description is compact and well-structured: it states the core action first, then the safety behavior, then the operational prerequisite and post-write action. Every sentence adds necessary information without 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?

The description covers the main operational context: what the tool does, overwrite/backup behavior, the bind-mount requirement, and daemon-reload side effect. Since an output schema exists, return-value documentation is not required here. It is complete enough for an agent to invoke the tool correctly, though it could mention behavior when the unit already exists.

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 provides 100% parameter coverage with clear descriptions for all four parameters. The tool description adds no additional parameter-level meaning, 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 names a specific verb ('Write') and resource ('unit file') and states its purpose ('setting up a service'). It also signals overwrite behavior with backup, which helps distinguish it from read-only unit tools and unit_file_remove_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 gives clear context: it is the tool for writing unit files as part of service setup, and it states an important environmental prerequisite (bind-mounted unit directory). It does not explicitly name alternatives or when-not-to-use cases, but the context is sufficient for an agent to select it appropriately.

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. 'List' implies a read-only operation, but the description does not disclose defaults, output shape, filtering behavior, or any 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?

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to stating the tool's purpose.

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, the schema fully documents parameters, and an output schema exists, so return values do not need description. The main gap is the absence of usage guidance, but that is already penalized under usage guidelines.

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

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

The input schema provides complete, detailed descriptions for all three parameters, including defaults and examples. The tool 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?

The description states a clear verb and resource: 'List systemd units.' It is unambiguous about what the tool does and is easily distinguished from status/show/start-style siblings, though it does not explicitly name alternatives or 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?

No guidance is given about when to use this tool versus sibling tools like unit_status_tool or unit_show_tool. The description does not mention filtering modes, loaded vs installed units, or any 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It states the key outcome ('cannot be started even manually') and a failure condition ('Refused for protected units'). It could additionally mention privilege requirements or reversibility, but the core behavior is clearly 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 two short sentences with no filler. The main effect is front-loaded, and the important limitation about protected units is included efficiently.

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 single-parameter tool with an output schema, the description is mostly complete: it names the action, effect, and a limitation. It omits minor operational context such as required privileges or how to reverse the operation, but the tool is simple enough that this is not a major 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% and the single parameter is already described as 'Systemd unit name.' The description adds little parameter-specific meaning beyond restating that a unit is the target, 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: 'Mask a unit so it cannot be started even manually.' It clearly distinguishes this from sibling tools like unit_start_tool and unit_unmask_tool by stating the intended effect.

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

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

The description implies when to use the tool: when a unit should be prevented from starting even manually. However, it does not explicitly mention alternatives such as unit_disable_tool or unit_unmask_tool, nor does it say when not to use it beyond noting protected units are refused.

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 behavioral disclosure. It correctly indicates the operation is non-restarting, which is a key behavioral trait. However, it does not disclose potential side effects, whether the reload is synchronous, or what happens if the unit is not running, which would be useful for an agent invoking the 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, concise sentence that front-loads the action and object. Every word earns its place, and there is no redundant or vague 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?

The tool is simple with one parameter and an output schema, so the description does not need to explain return values. However, given the sibling set includes unit_restart_tool and daemon_reload_tool, the description could have clarified the distinction between reloading a unit's config and reloading systemd's manager configuration. The lack of behavioral details (e.g., effect on running processes) leaves a moderate 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% for the single parameter, and the description adds no additional meaning beyond the schema's 'Systemd unit name'. The description's mention of 'unit' aligns with the parameter, but it does not clarify format, validity rules, or how the unit_name is resolved, so it adds minimal value over 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 ('reload') and resource ('unit's configuration'), and the title reinforces the tool's purpose. It is clear enough to distinguish from siblings like unit_start_tool or unit_restart_tool, though it does not explicitly name a sibling or contrast itself with 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 a unit's configuration has changed and needs to be reloaded without a full restart. However, it does not explicitly state when not to use it or mention alternatives like unit_restart_tool or daemon_reload_tool, leaving some ambiguity for an agent deciding between reload and restart.

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 discloses one trait – refusal for protected units – but does not mention that restart is a disruptive mutating operation, any permission requirements, or that it stops and starts the unit. This is marginal beyond the verb 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 concise two-sentence description with no filler. Both sentences carry meaning: the core action and the refusal constraint. It is appropriately front-loaded with the verb.

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 single-parameter tool with an output schema, the description is minimally complete: it states the operation and one key constraint. However, it omits operational context such as the disruptive nature of restart, permission requirements, and the relationship to reload, which would help an agent use it safely without 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 covers 100% of the parameter ('Systemd unit name'), so the baseline is 3. The description adds no additional semantics such as exact-name syntax, glob support, or validation rules beyond what the schema provides.

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

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

States a specific verb and resource ('Restart a unit'), which unambiguously distinguishes it from sibling tools like unit_start_tool, unit_stop_tool, and unit_reload_tool. The action is clear and not a tautology of the name.

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

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

Provides no guidance on when to restart versus using a sibling such as unit_reload_tool or unit_start_tool, and no mention of prerequisites like daemon-reload after unit file changes. The only context is a refusal condition for protected units, which is a restriction, not a usage guideline.

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. 'Dump' strongly implies a read-only operation, and the listed property categories are informative. However, it does not explicitly state that no state changes occur, nor does it mention privilege requirements or failure modes.

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 a front-loaded verb and concrete examples in parentheses. Every word adds value, and there is no redundant phrasing or 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 single-parameter tool with an output schema, the description covers the core semantics well: what the tool operates on and what kind of data it returns. A small gap is the lack of explicit guidance on how this differs from unit_status_tool, but that is not critical given the specificity of 'full property set'.

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 unit_name as 'Systemd unit name' with 100% coverage. The description adds no extra detail about the parameter, so the baseline of 3 is appropriate since the 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?

The description uses a specific verb ('Dump') and a specific resource ('full property set for a unit'), naming concrete categories such as dependencies, exec settings, and cgroup. This clearly distinguishes the tool from sibling unit_status_tool, which likely returns only status-level information.

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 need the complete property set of a unit rather than just status. However, it does not explicitly state when not to use it, nor does it name alternatives like unit_status_tool for lighter-weight queries.

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 carry the full burden of behavioral disclosure. 'Start a unit.' only states the basic action and does not describe resulting system state changes, requirement of privileges, failure behavior, or consequences of starting an already-active 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?

The description is terse and free of filler, and the core action is front-loaded. However, its brevity reflects under-specification rather than a deliberately structured explanation, so it is only minimally acceptable on this dimension.

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 parameter schema and presence of an output schema cover basic invocation details, but this is a state-changing systemd operation with no annotations and no usage context among twenty sibling tools. The description lacks enough context for an agent to choose this tool intentionally and understand the consequences of invoking 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 fully documents the single parameter unit_name as 'Systemd unit name', giving 100% schema description coverage. The description adds no additional parameter semantics, so the schema 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?

The description 'Start a unit.' merely restates the tool name and title ('unit_start_tool', 'Unit Start Tool') without adding any detail about what a unit is, which system is affected, or how this operation differs from the many sibling unit lifecycle tools. It is a clear sentence, but it contributes no informative value beyond the title.

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 unit_stop_tool, unit_restart_tool, unit_reload_tool, or daemon_reload_tool. No preconditions, side effects, or alternative routing are mentioned, leaving the agent to infer usage solely from sibling 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 provided, so the description must carry the behavioral burden. 'Get' and 'status' correctly signal a read-only inspection, and 'curated' indicates a selected subset of data rather than raw systemctl output. Yet it does not mention failure behavior, permission requirements, or whether any side effects occur, which keeps this from being more 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 sentence that front-loads the action and resource, followed by a colon-delimited list of the exact fields returned. There is no filler or redundant wording; every token contributes signal.

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

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

With a simple single-parameter input and an output schema present, the description does not need to explain return values. However, the lack of explicit differentiation from unit_show_tool leaves a selection gap, especially given the sibling list; otherwise the description is sufficient for invoking the tool.

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

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

The input schema fully documents the only parameter, unit_name, with a clear description and example. The tool description adds no additional parameter semantics beyond that, so the baseline of 3 applies because the schema already covers 100% 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') and resource ('unit') and names the exact curated fields: active/sub/load state, PID, memory, CPU. It is clear what the tool does, but it does not explicitly distinguish itself from the sibling unit_show_tool, which likely overlaps in 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 'Get curated status' implies the tool should be used when a compact status snapshot is needed. However, the description does not explicitly state when to use this tool versus alternatives like unit_show_tool, leaving the selection guidance 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?

The description discloses a meaningful behavioral guardrail: refusal for units on the protected list. However, with no annotations, it does not cover side effects such as process termination, whether the unit can be restarted afterward, permission requirements, or failure semantics. It is partially transparent but not complete.

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 zero wasted words. The core operation is front-loaded, and the protected-list caveat is placed clearly in the second sentence.

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 an output schema, the description is minimally complete: it states the action and a key restriction. It lacks usage context and behavioral details, but the low complexity means an agent can likely call it correctly with the schema.

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

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

Schema description coverage is 100%, and the single parameter is described as 'Systemd unit name.' The description adds no extra parameter-level detail, but the schema already carries the full burden, 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?

The description states a specific action and resource: 'Stop a unit.' This clearly distinguishes it from obvious siblings like unit_start_tool and unit_restart_tool by the action verb. It does not explicitly call out those siblings, but the operation is unambiguous.

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

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

The description gives no guidance on when to prefer stop over restart, reload, or mask, and does not mention prerequisites or consequences. The protected-list refusal is a constraint, not usage guidance, so an agent must infer the appropriate context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the core action but does not mention side effects (e.g., removing the mask symlink, making the unit startable again), administrative requirements, or any expected systemd behavior beyond the basic unmask 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, complete sentence with no filler, front-loading the key verb and object. Every word contributes to understanding the tool's purpose.

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 an output schema, the description is minimally viable but lacks behavioral and usage context that would help an agent handle edge cases or prerequisites. It is not fully complete, but it is not misleading either.

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% for the only parameter, unit_name, which is already described as 'Systemd unit name'. The tool description adds no additional 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?

The description uses a specific verb ('Unmask') and a clear resource ('a previously masked unit'), which directly distinguishes it from sibling tools like unit_mask_tool and unit_start_tool. There is no ambiguity about what action this tool performs.

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

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

The phrase 'previously masked unit' gives a clear context for when the tool is applicable, but the description does not explicitly state when to use this tool over alternatives or mention any exclusions. It relies on the name and sibling list to convey most of the usage guidance.

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