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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is known. The description adds only the scope 'all active timers' and does not explain irreversibility, confirmation behavior, or whether timers in other apps are affected.

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?

Four words, front-loaded with the verb and scope. Every word earns its place and there is no unnecessary detail.

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

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

For a zero-parameter destructive tool with annotations covering safety, the description is largely sufficient. It could mention whether cancellation is immediate or reversible, but the core operation is unambiguous.

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

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

The tool takes zero parameters, so the baseline score is 4. The description appropriately avoids parameter discussion and correctly implies no input is required.

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 (cancel) and resource (all active timers), making the action clear. However, it does not distinguish this bulk-cancel operation from the sibling cancel_timer tool, which likely targets a single timer.

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 explicit guidance on when to use this tool versus cancel_timer, nor does it mention any exclusions or prerequisites. Usage is only implied by the verb and resource.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the cancellation semantics are covered structurally, and 'cancel' is consistent with that. The description adds only the 'active' precondition; it says nothing about what happens with a stale or invalid ID or whether the operation is reversible.

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

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

A single front-loaded sentence with zero padding. It could arguably carry one more clause (e.g. invalid-ID behavior) without becoming verbose, but nothing present is wasted.

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

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

For a one-parameter mutation with annotations and no output schema, this is minimally sufficient — an agent can call it correctly. It is thin on outcome information, though: nothing about failure modes or how to obtain a valid timer ID (list_timers).

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 'id' parameter is already documented as 'Timer ID to cancel'. The description adds no format, source, or lookup detail beyond that, so the schema does all the work — baseline 3.

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

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

States a specific verb and resource ('Cancel an active timer') scoped to a single timer 'by its ID', which implicitly separates it from the sibling cancel_all_timers. It never names that sibling explicitly, so differentiation is left to inference.

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 'an active timer' hints that only currently running timers are valid targets, but there is no explicit when/when-not guidance and no reference to cancel_all_timers as the bulk alternative. An agent must infer the boundary conditions.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds useful scope (both official repos and AUR), but does not mention that the check may require network/database refresh, whether elevated privileges are needed, or what form the result takes. Note a mild tension: AUR checking typically hits the network while openWorldHint is false, though this is not a clear contradiction.

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

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

A single tight sentence with the resource and scope front-loaded; every word earns its place and there is no filler.

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

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

For a zero-parameter, read-only query with no output schema, the description covers what is checked and where. Only the result shape (list of packages vs. a boolean) is left unstated, which is a minor gap.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to disambiguate, and it does not introduce phantom parameter concepts.

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 ('Check') and resource ('system updates'), and adds meaningful scope by naming the two package sources covered (pacman official + AUR). It is clearly distinguishable from siblings like search_package or list_installed_packages, though it does not explicitly contrast itself with them.

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

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

Usage is only implied: an agent can infer this is the tool for 'are updates available?' rather than for searching or listing packages. There is no explicit statement of when to prefer it over search_package or of any preconditions (e.g., refreshing the package database first).

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

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

The annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered in structured data. The description reinforces this by saying 'entire', which tells the agent that all entries at once are affected, not just one. However, it says nothing about whether clearing is irreversible, whether an undo exists, or what happens to the current clipboard if it is non-empty. Those gaps hold it below a 4.

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?

It is a single short sentence, front-loaded with the action and resource, and there is no unnecessary text. The 'entire' qualifier is the most important word and appears prominently.

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 destructive tool with annotations that declare destructiveHint, the description covers scope and intent well. The only meaningful gap is the absence of a statement about irreversibility or recoverability, which matters for a wipe operation, but no output schema is needed and no parameters exist.

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 the description has nothing more to explain. The baseline for a no-parameter tool is a 4, and the description does not need to add anything.

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?

Population of a specific verb (wipe) and a specific resource (clipboard history), with the scope qualifier 'entire' making clear this is a bulk operation. It does not name its sibling delete_clipboard_entry, but 'entire' does implicitly distinguish it. The purpose is unmistakable.

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?

'Entire' implies the distinction from delete_clipboard_entry (single item removal), so an agent can infer when this tool is appropriate. However, there is no explicit statement of when NOT to use it, no mention of an alternative by name, and no precondition guidance (e.g., confirm before mass deletion).

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

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

The annotations already establish that this is a non-read-only, non-destructive, local mutation. The description adds useful behavioral context by specifying that only currently visible notifications are dismissed, implying history is unaffected and that the action applies to all visible items.

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?

It is a single sentence with no wasted words, and the scope ('all currently visible') is front-loaded in the description. The action and breadth are immediately clear.

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 action with annotations covering safety and no output schema, the description is complete enough to call the tool correctly. It could mention post-action state or output behavior, but those gaps are minor given the tool's low complexity.

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

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

The tool has zero parameters, so the schema carries no parameter semantics for the description to supplement. Following the zero-parameter baseline, a 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 uses a specific verb, 'Dismiss', with a clear resource, 'notifications', and adds scope via 'all currently visible'. This makes the action distinguishable from related tools like send_notification or list_notification_history, though it does not explicitly name sibling alternatives.

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

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

The phrase 'currently visible notifications' implies when the tool applies, but there is no explicit guidance on when to use it versus notification history, DND, or pause controls. Usage is inferable but not stated with 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is partly covered. The description adds that the close is graceful and can target a specific address, but it omits consequences such as unsaved data loss or failure behavior when no window is focused.

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 compact sentence with the core action and optional targeting front-loaded. There is no wasted text.

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

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

For a simple one-parameter tool with full schema coverage and annotations declaring its safety profile, the description gives enough to invoke it correctly. The main missing context is how it relates to kill_window, but the targeting behavior is 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 the single address parameter is already documented as a hex window address and omitting it targets the focused window. The description only restates the optional address behavior and adds no syntax or format details beyond the schema.

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

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

The description states a specific verb and resource: close the focused window, with an optional address target. It is clear what the tool does, though it does not explicitly distinguish itself from the sibling kill_window tool.

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

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

Usage is implied by 'gracefully close' versus a forceful kill, but the description does not state when to use this instead of kill_window or what happens if no focused window exists. It provides contextual hints rather than explicit routing guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds only the identifier flexibility, and says nothing about what happens on failure (device unpaired, adapter off) or whether an existing connection is replaced — useful context that is missing.

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

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

One front-loaded sentence with no filler. The identifying detail (MAC or name) arrives exactly where the agent needs it before calling.

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 no output schema and annotations covering the mutation profile, the description supplies what is needed: the action, the target, and the accepted identifier forms. Failure behavior would be nice but is not essential to call it correctly.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description adds genuinely new information: the device may be given by name as well as MAC address, which the schema does not document. The mismatch between the schema's MAC-only wording and the description's 'or name' creates mild ambiguity about accepted formats.

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 (connect) and resource (paired bluetooth device) plus the accepted identifier forms, so it is immediately distinguishable from disconnect_bluetooth and toggle_bluetooth. It does not explicitly name those siblings, but the verb makes the intent unambiguous.

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

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

'Paired bluetooth device' is the only usage constraint and it is stated obliquely as a precondition rather than as guidance. There is no explicit statement of when to prefer this over list_bluetooth_devices (to find the device) or get_bluetooth_status (to verify), so the agent must infer the workflow.

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

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

Annotations declare readOnly=false and destructive=false, so the mutating/non-destructive profile is covered. The description adds nothing beyond that: it doesn't say what happens to an existing connection, whether credentials are persisted for future sessions, what error is returned on wrong password, or whether a delay/async behavior should be expected.

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

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

One short, front-loaded sentence with no filler. It is efficient, though so terse that it borders on under-specification rather than true conciseness.

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

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

For a network-mutating tool with no output schema, the description should mention at least failure behavior (unknown SSID, bad password) and what a successful connection implies. None of this is present, leaving the agent to guess at the outcome.

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

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

Schema description coverage is 100%, with both ssid (required) and password (optional for open/saved networks) documented in schema. The description's mention of SSID is consistent with the schema but adds no new meaning, so baseline 3 applies.

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

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

States a specific verb and resource ('Connect to a WiFi network') plus the identifier used (SSID), so the action is unambiguous. It does not differentiate itself from siblings such as disconnect_wifi, toggle_wifi, or list_wifi_networks, but the name-plus-verb combination already separates it.

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

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

No guidance on when to use this versus toggle_wifi (which may also establish a connection) or when to call list_wifi_networks first to discover SSIDs. No prerequisites or conditions are stated.

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

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

Annotations already state non-read-only, non-open-world, non-destructive, so the safety profile is largely covered. The description adds the meaningful behavioral detail that this is an upsert (naming an existing macro silently overwrites it), which annotations do not reveal. It says nothing about validation of step tool names, error behavior, or how the macro is later executed, so there is a mild tension with destructiveHint=false that a caller overwriting an existing macro would care about.

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

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

Two sentences, front-loaded with the action verb, zero filler. The overwrite semantics and the steps structure are both stated in the minimum space required.

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 3-parameter write tool with no output schema, the description omits what happens on an invalid step tool name, whether the call returns the created macro, and how the macro is subsequently invoked (run_macro). Adequate but with clear gaps for an agent composing macros programmatically.

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

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

Schema coverage is 100% and every parameter (name, steps, description) is documented in the schema, including the nested step shape. The description restates the steps array shape with the optional 'params?' marker, which adds only marginal clarification over what the schema already says.

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 pair (create/overwrite) and resource (macro), and adds the structural fact that a macro is a list of {tool, params?} steps. That is enough to separate it from run_macro/get_macro/list_macros, although it never names those siblings 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?

Implied usage only: you call this to author a macro. There is no explicit guidance on when to use it versus run_macro or get_macro, and no warning about checking existing macros before overwriting one.

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

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

Annotations already declare this is non-read-only, non-destructive, and not open-world, so the safety profile is covered. The description adds that it targets the first empty workspace and 'effectively creates' one, but it does not clarify what happens when no empty workspace exists or whether a new workspace is actually created.

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 focused sentence with the action front-loaded and the parenthetical clarification kept brief. It contains no redundant or filler 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 zero-parameter tool with annotations and no output schema, the core invocation is clear enough. However, the vague 'effectively creates' wording leaves an important behavioral edge case unresolved: whether it fails, switches, or creates when no empty workspace is available.

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 for the description to explain. The empty schema is consistent with a no-argument workspace action, making the baseline of 4 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: switching to the first empty workspace, which clarifies the otherwise misleading create_workspace name. It does not explicitly distinguish itself from the sibling switch_workspace tool, but the 'first empty' detail gives useful specificity.

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

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

The description gives no explicit guidance about when to use this tool versus switch_workspace or next_workspace/prev_workspace. The intended use is only implied by the phrase 'first empty workspace'.

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

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

Annotations already declare destructiveHint=false, readOnlyHint=false and openWorldHint=false, so the safety profile is covered. The description contributes the relative-step model and default of 5 percent, but says nothing about boundary behavior (clamping at 0 or 100) or whether the change is immediate/persistent.

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

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

One sentence, front-loaded with the action and resource, with the parameter default folded in economically. Nothing extraneous.

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-optional-parameter, no-output-schema tool with full schema coverage and annotations covering safety, the description is essentially sufficient. Only the edge-case behavior at brightness limits is missing, a minor gap.

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

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

Schema description coverage is 100% and the single 'step' property is already documented as 'Percentage to decrease (default 5)'. The description restates that same information rather than adding meaning, so the baseline 3 applies.

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

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

States a specific verb and resource ('Decrease screen brightness') plus the magnitude semantics ('by N percent'), which cleanly separates it from increase_brightness, set_brightness, and get_brightness in the sibling list. An agent can select it without opening the schema.

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

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

Usage is only implied by the verb: the agent can infer this is a relative adjustment rather than an absolute set, but the description never explicitly says to prefer set_brightness for a specific target level or increase_brightness for the opposite direction. No exclusions or preconditions are stated.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds only the default step of 5; it doesn't say whether volume clamps at 0, whether the change persists, or what happens if the step exceeds current volume.

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

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

One short sentence with the default front-loaded alongside the action; nothing is wasted and nothing important is buried.

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-required-parameter convenience tool with no output schema, this is close to sufficient. The only real gap is the absence of any clamping or persistence note.

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

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

Schema coverage is 100% and the single 'step' parameter already documents 'Percentage to decrease by (default 5)'. The description restates the default without adding units, bounds, or behavior for out-of-range values.

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

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

States a specific verb+resource ('Decrease audio output volume') plus the magnitude semantics, and is immediately distinguishable from its sibling increase_volume. An agent needs no further reading to know what this does.

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

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

Usage is only implied by the name — lower the volume rather than raise it. There is no explicit statement of when to prefer this over set_volume or increase_volume, which are both available 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is carried by structured data. The description adds that the deletion is targeted to a single entry rather than the whole history, but says nothing about irreversibility or what happens when the ID 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?

One short sentence with the resource and the keying mechanism front-loaded; there is no filler and nothing to trim.

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

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

A destructive one-parameter tool whose annotations cover the danger signal, so the description is close to sufficient. It still leaves out where IDs come from and the outcome on unknown IDs, which an agent needs for correct invocation.

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

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

Schema description coverage is 100% and the single id parameter is documented as a 'Cliphist entry ID to delete'. The description's 'by ID' phrasing adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

The description names a specific verb (delete) and resource (a single clipboard-history entry) scoped by ID, so it is unambiguous what the tool does. It does not explicitly differentiate itself from the adjacent siblings clear_clipboard_history or paste_from_history, leaving that inference to the agent.

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

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

There is no statement of when to use this versus clear_clipboard_history (remove everything) or how to obtain a valid ID (list_clipboard_history). The agent must infer the workflow from sibling names alone.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and 'Delete' is consistent with them, so there is no contradiction. However the description adds nothing beyond the annotation: no statement about irreversibility, whether removal is permanent on disk, or what happens if the name is unknown. With the safety profile already structured, this is 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?

One short, front-loaded sentence with the verb and selector immediately visible and no filler. It is efficient, though the terseness borders on under-specification rather than optimal density.

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, irreversible mutation with no output schema, the description should say what deletion does to the stored macro and how a missing name is handled. None of that is present, leaving real gaps for a tool that cannot be undone.

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 'name' parameter is fully documented in the schema. The phrase 'by name' confirms that lookup is name-based rather than by id or index, but adds no format, case-sensitivity, or partial-match detail. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Delete a macro') plus the identifying key ('by name'), which cleanly separates it from run_macro, get_macro, list_macros and create_macro. It stops short of explicitly contrasting with any sibling, so it lands just below the top band.

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 versus the other macro tools, no prerequisite (does the macro need to exist / be disabled first), and no warning that the action is permanent. The agent must infer everything from 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?

Annotations only declare it is not read-only and not destructive; the description adds the meaningful side effect that the monitor is removed from the layout, not merely powered off. It stops short of saying whether the change is reversible (via enable_monitor) or how windows on that monitor are affected.

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

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

A single front-loaded sentence with zero waste; the verb, resource and effect all appear before any qualifier.

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 state-change tool with no output schema, the description covers the core effect, but omits recovery (enable_monitor), impact on open windows/workspaces, and whether the setting persists, which an agent would need to act safely.

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?

Only one parameter, and schema coverage is 100% ('Monitor name' is documented in the schema). The description adds nothing about name matching (case sensitivity, partial names, or how to discover valid names via list_monitors), so baseline 3 applies.

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

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

States a specific verb ('Disable') and resource ('monitor') and adds the concrete effect '(turns it off and removes from layout)', which distinguishes it from enable_monitor and implies a difference from set_monitor_dpms. The differentiation from set_monitor_dpms is only implicit, not named, so it falls short of a full 5.

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

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

The parenthetical implies when to use it (when you want the monitor off and out of the layout), but there is no explicit guidance on when to prefer this over set_monitor_dpms or mirror_monitor, nor any prerequisite (e.g., that the monitor must be currently enabled).

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

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

Annotations already disclose readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: it does not say whether pairing is retained, what happens if the MAC is unknown or not connected, or what the response looks like.

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

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

A single front-loaded sentence with zero filler; the verb, resource, and identifier are all stated immediately.

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

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

For a one-parameter command with full schema coverage and annotations, the definition is minimally adequate. It omits failure behavior (unknown MAC, already-disconnected device) and any indication of return value, which leaves an agent guessing about edge cases.

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 documented as the device MAC address. The phrase 'by MAC address' in the description merely mirrors the schema, adding no new syntax or format detail.

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

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

The description names a specific verb and resource ('Disconnect a bluetooth device') and the identifier used ('by MAC address'), so an agent can tell it apart from connect_bluetooth or list_bluetooth_devices. It stops short of explicitly differentiating itself from toggle_bluetooth, which also changes connection state.

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

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

Usage is implied by the verb – disconnect when you want to drop a connection – but there is no guidance on when to use this versus toggle_bluetooth, nor any precondition such as the device needing to be currently connected. No exclusions or alternatives are named.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the mutation profile is covered. The description adds nothing further: it doesn't say what happens if no network is connected, whether the change is reversible, or that the machine falls back to another interface. For a state-changing network tool this leaves a real 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?

One short, front-loaded sentence with the action verb first and no filler. It is appropriately sized for a zero-parameter tool, though it is sparse enough to leave the reader wanting a bit more context.

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

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

Annotations carry the safety profile and there are no parameters or output schema to explain, so the description is barely sufficient. It still omits the practical postcondition (loses connectivity, likely falls back to wired/Ethernet) that an agent needs to reason about consequences.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly implies the target network is whatever is currently joined rather than a named argument.

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?

"Disconnect from the current WiFi network" states a specific verb and resource, so the action is unambiguous. It doesn't explicitly distinguish itself from the sibling toggle_wifi, which could also disconnect the network, but the intent is still clear.

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

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

Usage is implied by the verb (tear down the active WiFi connection), but the description never says when to prefer this over toggle_wifi or how it relates to connect_wifi. No prerequisites or exclusions are given, so the agent must infer routing.

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

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

Annotations already declare it is a mutation (readOnlyHint=false) that is non-destructive, so the agent knows the safety profile. The description usefully adds that the monitor comes back with default settings — implying prior scale/position/mirror customizations are reset — but says nothing about behavior on an invalid or unknown monitor name. With annotations covering safety, this is adequate but thin.

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

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

One short sentence with zero filler, and the key qualifier ("default settings") is present rather than buried. Nothing to trim or reorder.

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, non-destructive toggle with full schema coverage and annotations, this covers nearly everything an agent needs. The only real gap is the absence of a pointer to the disable_monitor/list_monitors workflow that would confirm the name.

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 includes a concrete example ('HDMI-A-1'), so the parameter is fully self-documenting. The description adds only the implicit contract that the name refers to a disabled monitor, no format or resolution details beyond the schema.

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

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

States a specific verb and resource ("Enable a disabled monitor") plus a scoping qualifier ("with its default settings"), which clearly separates it from disable_monitor and list_monitors in the sibling set. It does not explicitly name the counterpart tools, so it falls short of a 5.

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

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

Usage is only implied by the precondition "disabled" — an agent can infer this applies to an off monitor. There is no explicit guidance on when to prefer it over set_monitor_dpms or mirror_monitor, and no note about what to do if the monitor is already enabled.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the concrete metadata fields the caller receives, but says nothing about behavior on a missing/unreadable path or whether symlinks are followed.

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

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

One front-loaded sentence with no filler; the useful information (returned fields) is included after the verb. Efficient, though it could carry one more clause on path format without bloat.

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-param read tool with no output schema, enumerating the returned fields is the right compensation and it does so. Gaps remain around path resolution and failure behavior for a nonexistent file, which an agent would hit in practice.

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

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

Schema coverage is 100% and the single param is documented, so the baseline is 3. The description adds nothing about path format — absolute vs relative, tilde expansion, or whether directories are accepted — which is the one thing the terse 'File path' schema leaves open.

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 ('Get') and resource ('metadata about a file') and enumerates the returned fields (size, type, modification time). This distinguishes it in practice from siblings like read_file (content) or list_directory, though no sibling is named 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?

No guidance on when to prefer this over read_file, list_directory, or open_file_manager — the agent must infer that this is the metadata-only option. No mention of preconditions such as the file existing.

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

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

Annotations already state readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is mostly covered. The description adds little beyond that: it does not explain what happens if no window matches, how multiple matches are resolved, whether focusing also switches workspaces, or whether the class and title filters are combined with AND/OR. For a state-changing focus operation, these are meaningful gaps.

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. Every word contributes to stating the action and matching basis, making it as concise as possible for this tool.

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

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

For a two-parameter mutation tool with no output schema, the description is too thin. It omits whether at least one of class or title is required in practice, what happens with zero parameters, ambiguity when multiple windows match, and any side effects such as workspace switching.

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 schema already documents both class and title with examples. The description only restates that windows can be matched by class name or title substring, adding no new meaning about combination logic or required combinations. Baseline 3 applies when 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 names a specific verb and resource: focus a window. It is distinguishable from siblings such as close_window, kill_window, list_windows, and get_focused_window. It does not explicitly name or differentiate against those siblings, so it falls short of a 5.

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

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

The description offers no explicit guidance on when to use this instead of get_focused_window or list_windows, nor any prerequisites. The only implied usage is that it is for changing window focus, which is not enough to guide tool selection reliably.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The word 'active' adds the useful scoping concept (the workspace currently in focus, not the full set), but nothing is said about what information is returned or whether 'active' here means focused-on-this-monitor.

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

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

One short sentence, front-loaded with the verb and the key scoping adjective 'active'. It wastes no words, though it is on the terse side given no other guidance is present.

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

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

With no output schema, the agent cannot tell what 'information' is returned (id, name, monitor, window count). Given the many workspace-related siblings, the description should at least hint at the payload or contrast with list_workspaces.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate and it correctly avoids inventing inputs.

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 ('Get information') and resource ('the currently active workspace'), which distinguishes it from the sibling list_workspaces by scoping to the single active workspace. It never explicitly names that sibling, so differentiation is implied rather than stated.

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

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

There is no guidance on when to call this versus list_workspaces or get_focused_window; the agent must infer that this returns only the active workspace while list_workspaces returns all. No preconditions or exclusions are mentioned.

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

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

Annotations already establish readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds real value by enumerating the returned fields, which matters since there is no output schema. It stops short of stating behavior when no battery exists (desktop) or how time remaining is reported while charging/plugged in.

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

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

One short sentence, front-loaded with the verb and resource, with the return contents appended. Every clause earns its place and there is no filler.

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

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

With no parameters, no output schema and full annotation coverage, the description carries the return-value burden and does so adequately. The only gap is edge-case behavior (no battery present, unknown charging state) for a zero-arg sensor read, which is minor.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; no parameter semantics are missing.

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

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

States a specific verb (get) and resource (battery info) plus the three concrete fields returned: percentage, charging state, time remaining. That distinguishes it cleanly from sibling power/thermal tools like get_power_profile, get_thermal_info and get_system_info, though it never names 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?

Usage is only implied by the resource name – an agent can infer 'call when you need battery status.' There is no explicit when-to-use, no exclusion (e.g. when to prefer get_power_profile or get_thermal_info for power questions), and no stated fallback for machines without a battery.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds only that both power state and connected device info are returned; it says nothing about behavior when the adapter is absent, disabled, or Bluetooth is off.

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

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

One short sentence, front-loaded with the verb and containing only the two facts that matter. Nothing to trim.

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

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

With no output schema, the description must convey what comes back, and it does (power state plus connected devices). It could note the shape (e.g., device names/addresses) or unavailable-adapter behavior, but for a zero-parameter status read it is essentially sufficient.

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

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

The tool takes zero parameters, which is the baseline-4 case. The description correctly implies no inputs are needed to retrieve status.

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?

Specific verb (get) plus resource (bluetooth status) with two named outputs: power state and connected devices. It is clear, but it doesn't distinguish itself from the nearby list_bluetooth_devices sibling, which likely returns similar device 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?

Usage is implied by the name and the read-only nature — check whether Bluetooth is on and what's attached. There is no explicit when-to-use/When-not phrasing and no pointer to list_bluetooth_devices versus this tool.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety and locality are covered by structured data. The description's only added behavioral fact is the return format (percentage), which is genuinely useful given there is no output schema, but nothing is said about failure modes (no backlight available, display vs. external monitor) or whether the value is a raw device percentage.

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

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

One sentence, front-loaded with the verb, and every clause (current, screen, percentage) earns its place. Nothing to trim.

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 tool with annotations covering safety and openWorld, the description plus annotations cover nearly everything an agent needs: what it returns and that it is a safe read. Only minor edge-case behavior (which display, what happens with no backlight) is unaddressed, which is acceptable for this complexity.

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

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

The tool takes zero parameters, so per the baseline rule this scores 4. The description correctly makes no parameter claims and instead spends its words on the return value.

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

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

States a specific verb ('Get') and resource ('current screen brightness') plus the return unit ('as a percentage'). It is implicitly distinct from set_brightness/increase_brightness/decrease_brightness, but never names them, so sibling differentiation relies on naming convention rather than on the description itself.

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 read-only nature of 'Get' implies when to use it, and the sibling set makes the read-vs-adjust split obvious, but the description never explicitly says 'use this to check brightness before/after adjusting' or excludes any alternative. Usage is inferred, not stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds one piece of real context — that only text content is returned, implying image clipboard contents are out of scope — but says nothing about empty-clipboard behavior or how the value is returned.

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

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

A single front-loaded sentence with no filler; appropriately sized for a zero-parameter read. It is terse to the point of omitting any routing or return-value detail, which is a completeness issue rather than a verbosity one.

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

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

For a no-argument, read-only accessor with annotations covering safety and no output schema, the description covers what the tool returns at a high level ('text content'). A mention of what happens when the clipboard is empty or non-text would make it fully complete.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly implies no input is needed to read the current clipboard.

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 ('Get') and resource ('current clipboard text content'), which is unambiguous on its own. It does not distinguish itself from siblings like list_clipboard_history, paste_from_history, or set_clipboard, so it falls short of a 5.

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

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

Usage is only implied by the get/set naming symmetry with set_clipboard and the presence of list_clipboard_history/paste_from_history. There is no explicit statement of when to use this versus reading history or pasting directly, and no 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds value by enumerating what data is returned (model, usage %, temperature, frequency) in the absence of an output schema, though it omits units, freshness, and whether values are instantaneous or averaged.

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 listing exactly the returned metrics with no filler. Every clause maps to a distinct piece of output.

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

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

With no parameters and no output schema, the description's job is to describe return values, which it does at a reasonable level. It stays a notch short of complete by not stating units for temperature/frequency or how usage is sampled.

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, so the baseline is 4; the description correctly implies a fixed, unfiltered snapshot with nothing to configure.

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

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

States a specific verb and resource ('Get CPU model, usage percentage, temperature, and frequency'), which is unambiguous against siblings like get_memory_info or get_gpu_info. It doesn't explicitly distinguish itself from get_system_info or get_thermal_info, which partially overlap on temperature/system data.

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

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

Usage is only implied by the name and returned fields; there is no statement of when to prefer this over get_thermal_info or get_system_info, and no exclusions. For a zero-argument read tool this is mostly harmless, but the guidance is absent rather than 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?

The readOnlyHint and openWorldHint annotations already establish that this is a safe, local read. The word 'currently active' adds a little context about what state is reported. Beyond that the description says nothing extra, and because there is no output schema it could have said more about what comes back.

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

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

The description is a single well-formed sentence with the key qualifier 'currently active' placed before the resource. No filler.

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

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

A zero-param read getter is a simple tool, and the description plus annotations cover the essentials. It would be stronger if it confirmed the return type, since no output schema exists to define 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?

There are no parameters, so the schema needs no explanation. The description correctly treats this as a no-argument call.

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

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

The description gives a specific verb and resource: 'Get the currently active HyDE theme name'. That is enough to tell it apart from sibling setters like set_theme and next_theme. It does not, however, draw an explicit boundary against sibling getters such as list_theme_wallpapers or get_wallbash_mode.

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 read usage but never says when to call this instead of list_themes or next_theme. For a zero-parameter read-only getter the intended use is fairly obvious, which keeps it at minimum viable rather than misleading.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful granularity ('per mount point') but does not disclose return format details, units, or whether all mounts are included, so it goes only modestly beyond the structured data.

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 short sentence that is front-loaded with the action and scope. Every word earns its place with no redundancy.

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

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

For a simple no-parameter read operation whose annotations cover safety, the description is nearly complete. It could mention whether all mount points are always returned, but no output schema exists so return-value detail is not required.

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

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

The tool takes zero parameters, so the baseline is 4. The description adds no parameter semantics because none exist, which is appropriate.

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

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

States a specific verb+resource ('Get disk usage') and scope ('per mount point'), which is clearer than a generic system-info call. It does not explicitly differentiate from sibling tools such as get_system_info, so it falls short of a 5.

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

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

The description implies when a disk-usage query is relevant but gives no explicit when-to-use guidance, no exclusions, and no mention of related siblings like get_system_info. An agent must infer usage context.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered without description help. The description adds no behavioral context of its own and does not say what the check returns (a boolean state, a paused/off distinction), so it neither helps nor contradicts.

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

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

A single front-loaded sentence with no filler. Nothing is buried and nothing is wasted.

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

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

With no parameters, no output schema, and a trivial read operation, the description is nearly sufficient. However, because there is no output schema, the description should state what the check yields and how this differs from toggle_dnd and set_notification_paused; that gap leaves the agent guessing about the return value.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Schema coverage is moot at 0 params, and 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 gives a specific verb + resource ('Check if Do Not Disturb mode is enabled'), which is clear and unambiguous. It does not differentiate itself from the mutating siblings toggle_dnd or set_notification_paused, so the agent must infer the read-vs-write split from the tool name alone.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the closely related toggle_dnd or set_notification_paused. The only signal about alternatives comes from the 'get_' prefix in the tool name, not from the description text.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds nothing beyond that: it does not say what 'details' are returned, whether it fails when no monitor is focused, or how it resolves a multi-monitor setup. With no output schema, this is the main 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?

One short, front-loaded sentence with no filler. It is not wasteful, though it is arguably undersized for a tool with no output schema.

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

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

For a trivial zero-arg getter with read-only annotations this is close to sufficient, but with no output schema the agent has no idea what fields 'details' returns or what happens in edge cases like no focused monitor. A brief mention of the return shape would close the loop.

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?

Zero parameters, so the baseline is 4. There is no parameter semantics to explain and the description correctly presents the tool as argument-free.

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

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

States a specific verb and resource ('Get ... monitor's details') and the qualifier 'currently focused' separates it from list_monitors or get_focused_window. However it never names those siblings explicitly, so differentiation relies on the agent inferring from 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?

The word 'focused' implies the use case (query the monitor the user is looking at, rather than enumerating all monitors), but no sentence says when to prefer this over list_monitors or what to do if no monitor is focused. Usage is only implied.

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

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

Annotations already declare readOnlyHint and openWorldHint:false, so mutation safety is covered. The description adds nothing further — 'details' is undefined, and with no output schema an agent cannot know what fields come back or what happens when no window is focused.

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

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

One short, front-loaded sentence with no padding. Brevity is appropriate, though it is arguably under-specified rather than maximally informative.

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

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

For a tool with no output schema, the description should describe what 'details' means (title, class, PID, geometry) and the no-focused-window edge case. None of that is present, leaving the return contract entirely unknown.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies.

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 ('Get') and resource ('details of the currently focused/active window'), which is clearly distinct from list_windows or get_active_workspace. It stops short of naming the sibling it differs from, but the scope word 'focused' does most of the differentiation work.

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

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

There is no guidance on when to call this versus list_windows (all windows) or screenshot_window. Usage is only implied by the phrase 'currently focused'; no alternatives or preconditions are mentioned.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered without the description. 'Currently active' adds the notion of live state rather than a persisted setting, which is mildly useful, but nothing about what 'active' means operationally (e.g. whether it requires a session, daemon, or can fail).

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

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

A single, front-loaded sentence with no filler; the parenthetical disambiguation earns its place. It is arguably under-sized given that it omits the return value, but it is not padded or bloated.

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

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

There is no output schema, so the description is the only place the return value could be described, and it does not say that a boolean active/inactive state is returned or what happens if gamemode is unavailable. For a no-parameter status query with annotations covering safety, this leaves one meaningful gap.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly adds no parameter prose, since there is nothing to document.

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 ('Check') and resource ('gamemode'), and clarifies with the parenthetical '(performance mode)' that gamemode is a performance setting rather than a media or gaming mode. It does not distinguish itself from the sibling toggle_gamemode, which is the obvious confusion risk.

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

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

No guidance on when to call this versus toggle_gamemode or when the check is warranted. The read-only nature is implied by 'Check', but there is no explicit statement that this must be called before toggling, or that it is a query-only sibling of the toggle.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered by structured data. The description adds the content of the response (model, usage, temperature, VRAM) but says nothing about failure modes when no GPU/tooling is present or about formatting/pagination. Some added value, but modest.

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

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

A single front-loaded sentence with no filler. Slight redundancy between 'usage' and 'VRAM usage', but overall tight and appropriately sized for the tool's simplicity.

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

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

No output schema exists, and the description compensates by listing exactly which GPU metrics are returned, which is what an agent needs to decide whether to call it. The only gap is behavioral context for the no-GPU case, which annotations do not cover.

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

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

The tool takes zero parameters, so per the baseline this lands at 4. The description correctly spends its words on outputs rather than inventing 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?

Specific verb 'Get' with a clearly scoped resource (GPU) and an enumeration of the four returned data points: model, usage, temperature, VRAM usage. This is trivially distinguishable from siblings like get_cpu_info and get_memory_info by resource alone, though it never explicitly references 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 when-to-use or when-not-to-use guidance, no prerequisites (e.g. driver/GPU presence), no mention of alternatives. For a zero-parameter read getter the invocation context is largely self-evident, so implied usage is adequate but nothing more.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds one useful behavioral fact — only active bindings are returned, not the full config — but says nothing about return shape or whether runtime-added binds are included.

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

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

A single front-loaded sentence with no filler. Every word (including 'active') carries meaning.

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

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

For a trivial no-param read tool with annotations covering safety, this is nearly adequate. However, there is no output schema, so the description could have stated what a keybinding entry looks like (mods, key, dispatcher, args) — the agent has no idea what it will receive.

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

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

The tool takes zero parameters, so the schema leaves nothing to explain. Baseline 4 applies; no parameter-level context is needed or missing.

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

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

'List all active Hyprland keybindings' names a specific verb (List) and resource (Hyprland keybindings) with a scope qualifier ('active'). It is distinguishable from neighbors like get_hypr_option or get_keyboard_layout, though it doesn't explicitly contrast with them.

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

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

There is no guidance on when to call this versus related Hyprland tools such as get_hypr_option, hypr_reload, or get_keyboard_layout. The agent must infer the use case purely from 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds that it returns the option's current value and shows the expected 'section:name' naming convention, which is useful context beyond the annotations.

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

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

A single, front-loaded sentence with no filler. The examples are brief and directly support correct invocation.

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

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

For a simple one-parameter getter with read-only annotations, the description is nearly complete. The only missing element is explicit routing advice versus the corresponding setter, but an agent has enough to call it correctly.

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

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

Schema description coverage is 100%, so the single 'option' parameter is already fully documented in the schema. The description's examples reinforce the naming format but do not add meaning beyond what the schema provides; baseline 3 is appropriate.

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

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

States a specific verb and resource ('Get a Hyprland config option's current value') and gives concrete example option names. It implicitly contrasts with set_hypr_option by emphasizing 'current value', but does not explicitly name the sibling.

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

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

Read-only retrieval is implied, and an agent can infer that this is for checking configuration rather than changing it. However, it never explicitly says when to prefer this over set_hypr_option or hypr_reload, so usage guidance is only implied.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety and locality are covered. The description only adds the 'all interfaces' scope; it says nothing about return shape, ordering, or whether virtual/down interfaces are included.

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

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

A single front-loaded sentence with no filler. It is arguably too terse given the ambiguity with get_network_status, but no sentence is wasted.

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 getter with annotations covering the safety profile, the description tells the agent enough to call it. The only gap is the absent output shape, which is bounded by the tool's simplicity and the lack of an output schema.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is 100% and the empty schema is consistent with 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?

States a specific verb ('Get') and resource ('network interface IP addresses') with scope ('all'), so the agent knows exactly what is returned. It does not distinguish itself from the sibling get_network_status, which is the nearest ambiguous 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?

There is no statement of when to use this versus get_network_status or when not to use it. A single trivial getter needs little guidance, but nothing here helps the agent choose between the two network-related tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds no further behavioral context (return format, whether layout is per-keyboard, latency), but a zero-param read has little to disclose.

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 short sentence that front-loads the verb and resource with no waste. Appropriately sized for a trivial getter, though it borders on under-specification.

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

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

No output schema exists, so the description would ideally hint at the return value (e.g., a layout identifier such as 'us' or 'de'). As written it does not, leaving the return shape ambiguous, though the tool is simple enough that this is a minor gap.

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

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

The tool takes zero parameters, so the schema carries all the necessary structure and the baseline is 4. Nothing in the description is needed to clarify inputs.

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 ('Get') and resource ('current keyboard layout'), so the agent knows exactly what the tool retrieves. It does not mention the sibling that changes this state (switch_keyboard_layout), so differentiation is left implicit.

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?

Read-only query intent is implied by 'current', and the surrounding sibling names make the read/write split inferable. However, no explicit when-to-use or pointing to switch_keyboard_layout as the counterpart.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds only that it returns "full details," saying nothing about error behavior for missing macros or the shape of the return. Adequate but thin given the lower bar set by annotations.

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

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

A single short, front-loaded sentence with no filler. It is efficient, though the terseness leaves little room for routing context.

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

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

For a simple read-only, single-parameter lookup with full schema coverage and annotations covering safety, the description is sufficient to call correctly. Minor gap: no statement of behavior when the named macro does not exist.

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

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

With one parameter at 100% schema description coverage, the schema already documents the name field. The description's phrase "specific macro" confirms the name identifies the target but adds no format or lookup semantics beyond the schema.

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

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

The description states a specific verb and resource ("Get full details of a specific macro"), which is unambiguous about the operation. It does not differentiate itself from siblings like list_macros or run_macro, so it falls short of a 5.

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

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

There is no explicit guidance on when to use this over list_macros (for discovery) or run_macro (for execution). The single-macro-by-name usage is only weakly implied by "specific macro" and the required name parameter.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safe-read profile is covered. The description's contribution is the field list, which is useful since no output schema exists, but it omits edge-case behavior (no active player, paused vs stopped, position units).

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

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

A single front-loaded sentence with the resource stated first and the returned fields enumerated after a colon. No filler and nothing misplaced.

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

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

With no output schema, the inline field list carries the return-value burden well. What remains uncovered is degenerate-state behavior — what the agent sees when no track is playing — which matters for a status tool an agent may poll blindly.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify about inputs, and it correctly focuses on outputs instead.

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 ('Get') and resource ('currently playing track info') and enumerates the fields returned. It implicitly differs from list_media_players, but never states that distinction explicitly, so an agent must infer which to pick.

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

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

Usage is only implied by the phrase 'currently playing' — it suits status polling. There is no explicit when-to-use guidance, no mention of the related media_play_pause/list_media_players siblings, and no statement of what happens when nothing is playing.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds the set of memory metrics returned, which is useful, but says nothing about units (bytes/percent), swap semantics, or whether swap is null when absent.

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

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

A single front-loaded line with zero waste, listing the key returned fields inline. Nothing could be trimmed without losing information.

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

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

With no output schema and only annotations for safety, the description carries the return-value burden and does so at a high level by naming the four metrics. Units and swap edge cases are the only meaningful gaps.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate. No misleading parameter references are present.

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

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

States a specific verb and resource ('Get RAM usage') and enumerates the metrics returned (used, total, available, swap). It is clear enough to distinguish from get_cpu_info or get_disk_info, though it never explicitly contrasts with get_system_info, which could plausibly report memory too.

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

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

No explicit when-to-use or when-not guidance, and no mention of how it relates to sibling get_system_info. Usage is only implied by the resource name 'RAM usage', which is generally enough for an agent to infer this is the memory-specific query.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, establishing a safe local read. The description adds value by specifying the two pieces of data returned (volume percentage and mute state), which matters because there is no output schema. It does not cover error cases or unavailable-device behavior, but for a simple local getter that is a minor 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?

A single front-loaded sentence with no filler. Every word contributes: the resource, the two return values, and the implicit read nature.

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, annotation-covered local getter with no output schema, the description supplies the missing return-value information. An agent can call it correctly without further detail.

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

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

The tool takes zero parameters, so there is nothing to document and the baseline is 4. The description correctly implies no inputs are 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?

States a specific verb and resource: get microphone input volume percentage and mute state. The word 'microphone' distinguishes it from the sibling get_volume, which handles output volume, though it does not explicitly name that 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?

Usage is implied: it is the read-only status check for microphone input, complementary to set_mic_volume and toggle_mic_mute. However, it offers no explicit when-to-use guidance or named alternatives, leaving the agent to infer the distinction from the 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds real value by disclosing the shape of the returned data (SSID, IP, signal strength, device type), which matters here because there is no output schema. It stops short of noting whether it reports only the active connection or fails when offline.

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

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

A single front-loaded sentence with the verb and resource first and the returned fields parenthesized after. Zero 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?

With no output schema and no parameters, the description carries the burden of telling the agent what comes back, and it does so by naming the four fields. It would be complete at 5 if it clarified behavior when disconnected or how it differs from the narrower network siblings.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the baseline of 4 applies. Nothing in the description misdescribes inputs.

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

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

States a specific verb and resource ('Get current network connection status') and enumerates the payload (WiFi SSID, IP, signal strength, device type). It's clear on its own, but it doesn't distinguish itself from overlapping siblings like get_ip_addresses, list_wifi_networks, or get_bluetooth_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?

Usage is only implied by the word 'current' — an agent can infer this is a point-in-time snapshot versus the enumerating siblings, but the description never says when to prefer it over get_ip_addresses or list_wifi_networks. No exclusions or alternatives are named.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds the domain of possible return values (performance, balanced, power-saver), which is genuinely beyond annotations — though it doesn't state the exact response shape.

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

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

A single front-loaded sentence with the verb first and the value domain in parentheses; nothing superfluous.

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 getter with no output schema, the description supplies the key missing piece — the set of possible profile values. Only the exact return format (string vs object) is left unstated, a minor gap.

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

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

The tool takes zero parameters, so the baseline is 4. There are no parameter semantics for the description to compensate for.

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

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

States a specific verb and resource (get the current power profile) that is unmistakably distinct from the setter in the sibling list, set_power_profile. It does not explicitly name the sibling, but the read nature is clear from 'Get the current'.

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

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

Usage is implied by 'current' — read state rather than change it — which naturally routes the agent away from set_power_profile. No explicit when/when-not guidance or named alternative is given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds that the value is read from the 'current' state and that the result is a style number, which hints at the return type, but says nothing about valid ranges or what the number means.

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 short sentence with zero filler, and the resource is front-loaded. It is minimally sized rather than padded, though it stops short of adding routing or return-value context that would justify a 5.

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

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

For a simple zero-param read with annotation coverage and no output schema, the description is adequate but bare. It could note the valid style range or point to set_rofi_style for modification, which would make it complete rather than merely sufficient.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; no parameter gaps exist to compensate for.

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

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

States a specific verb ('Get') and resource ('the current rofi launcher style number'), so the agent knows exactly what is retrieved. It pairs implicitly with the sibling set_rofi_style but never names it, so the differentiation is left to inference rather than stated.

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

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

Usage is only implied by the get/set naming symmetry with set_rofi_style in the sibling list. There is no explicit statement of when to call this versus set_rofi_style, and no prerequisite or exclusion noted.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description's one piece of added value is naming the two distinct returned values (idle timeout vs lock timeout), but it gives no units, defaults, or format for them.

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

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

A single front-loaded sentence with no filler; both returned values are named immediately.

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

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

With no output schema and no parameters, the description carries the return-value burden and it does identify both outputs. The remaining gap is units/format (seconds vs minutes, how lock timeout relates to idle timeout), which an agent might want before presenting results.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain and the baseline of 4 applies. Nothing in the description misleads about inputs.

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

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

The description states a specific verb (get) and two specific resources (screen idle timeout, lock timeout), so the agent knows exactly what values it retrieves. It does not explicitly differentiate itself from siblings, though no sibling overlaps with this 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?

Usage is implied by the read-only getter naming; there are no conditions, prerequisites, or named alternatives. For a trivial no-parameter getter this is adequate but nothing is explicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds no behavioral context beyond the field list — no mention of permissions, environment assumptions, or caching — but for a zero-parameter read-only getter this is only a minor gap.

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

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

The description is a single front-loaded sentence with no redundant or filler content. Every listed field earns its place by clarifying the return scope.

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 getter, the enumerated fields provide enough context to invoke the tool correctly, and annotations cover the safety profile. Minor gaps remain around return formatting or environment caveats, but 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 takes zero parameters and schema description coverage is 100%, so parameter semantics are inherently complete. The baseline for zero-parameter tools is 4.

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

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

The description uses a specific verb ('Get') and names the exact system fields returned: OS, kernel version, hostname, Hyprland version, and shell. It is clearly distinguishable from narrower sibling tools like get_cpu_info or get_gpu_info by the field list, but it does not explicitly state sibling differentiation.

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

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

Usage is implied by the returned fields, but there is no explicit guidance on when to use this versus get_cpu_info, get_gpu_info, get_uptime, or other system-related siblings. 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.

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds nothing beyond the resource name — no mention of units, sensor source, refresh/liveness, or value format — so it earns only minimal credit given the annotation baseline.

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

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

A single front-loaded sentence with no filler. Every word earns its place for a no-param read tool.

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

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

For a simple read tool with no params, no output schema, and safety annotations, the description covers the core purpose. However, with no output schema, it could have added expected return values (units, per-core vs package, availability when sensors are missing) and does not.

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, which is the baseline-4 case. No parameter-level semantics are needed or expected.

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?

Specific verb 'get' and resource 'CPU and GPU temperatures' clearly state what the tool returns. It is reasonably distinguishable from siblings like get_cpu_info and get_gpu_info, though the description never clarifies whether those siblings already include temperature, leaving some overlap ambiguity.

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

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

Usage is implied by the resource (thermal readings), but there is no explicit guidance on when to use this versus get_cpu_info or get_gpu_info, which likely surface related data. No exclusions or alternatives are named.

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?

readOnlyHint=true and openWorldHint=false already establish this as a safe, local read, so the description's burden is low. It adds that load averages are included alongside uptime, which is modestly useful return-content context, but says nothing about the machine's time units or the load-average windows.

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

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

A single front-loaded sentence naming both outputs with no filler. Nothing could be removed without losing 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 parameterless, well-annotated read tool with no output schema, the description covers what an agent needs in order to choose and call it. Only minor detail, such as the units of uptime and the 1/5/15-minute load windows, is absent.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No misleading parameter hints are present.

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?

Specific verb plus resource ('Get system uptime') and it also names the secondary data returned ('load averages'). It does not distinguish itself from the similar read-only siblings get_system_info, get_cpu_info, or get_memory_info, so an agent must infer the boundary itself.

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

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

Usage is implied only: it's clearly a diagnostic read, but the description never says when to prefer it over get_cpu_info or get_system_info, nor any exclusions. For a zero-parameter info tool that gap is small but real.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. With no output schema, the description adds real value by stating what the return contains: a volume percentage and the mute state. It stops short of describing default-sink scope or the unit/type of the value.

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 short sentence with no filler, front-loading the action and the two pieces of state returned. Nothing could be trimmed without losing information.

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

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

For a zero-arg read tool with no output schema, the description covers the essential return fields. A small gap remains: it does not say whether the volume reflects the default sink or the active device, which matters given the sibling set includes list_audio_sinks and set_default_sink.

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?

Zero parameters, so the baseline of 4 applies. There is nothing for the description to disambiguate, and it correctly implies no inputs are 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?

A specific verb ('Get') plus a precisely scoped resource ('current audio output volume percentage and mute state'). It clearly distinguishes itself from get_mic_volume, list_audio_sinks, and the set/increase/decrease/toggle siblings by naming the output-volume read 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?

Usage is implied: it is the read counterpart to set_volume/increase_volume/toggle_mute, so an agent can infer 'call this to read state before adjusting'. But no explicit when-to-use or when-not guidance, and no alternative is named (e.g., versus get_mic_volume or list_audio_sinks).

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

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

The annotations already establish that this is a read-only, non-open-world operation, so the description does not need to restate safety behavior. The description adds useful detail by naming the possible mode values (theme/auto/dark/light), which helps the agent interpret the result. It does not describe edge cases or output structure beyond those values.

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 wasted words. It immediately states the action, the target, and the possible values.

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 getter with no output schema, the description is complete enough: it says what is retrieved and lists the likely return values. The annotations cover safety and open-world behavior, so no important context is missing for correct invocation.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The schema is empty and complete for this operation, and the description correctly does not introduce any parameter-related expectations. Baseline for zero parameters is 4.

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

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

The description uses a specific verb and resource: 'Get current wallbash color mode.' It also enumerates the possible modes (theme/auto/dark/light), making the purpose unambiguous. It does not explicitly name or differentiate itself from siblings like get_current_theme or get_waybar_mode, so it stops short of a 5.

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

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

The description implies usage as a read-only getter for the current wallbash mode, but it does not state when to use this tool instead of related siblings such as get_current_theme, get_waybar_mode, or set_wallbash_mode. The implied context is adequate but not explicitly guided.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description's added value is disclosing the return value (a file path), which matters because there is no output schema, but it says nothing about behavior when no wallpaper is set or what format the path takes.

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 ten-word sentence with the resource and return value front-loaded and zero filler. Nothing could be removed without losing information.

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

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

For a zero-argument, read-only lookup with no output schema, naming the returned artifact (file path) is the essential piece an agent needs to chain it into later calls such as read_file or set_wallpaper. Missing only edge-case behavior (no wallpaper set, path format).

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?

Zero parameters, so per the baseline this scores 4. There is no parameter surface for the description to clarify or omit.

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 ('Get') and resource ('currently active wallpaper') plus the exact return ('file path'), so the agent knows precisely what comes back. It does not distinguish itself from siblings such as list_wallpapers or get_wallpaper_colors, which is the only thing keeping it from 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 explicit guidance on when to use this versus list_wallpapers (enumerate options) or get_wallpaper_colors (read the derived palette). The read-only 'current value' framing implies usage, but the agent must infer it 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safe-read nature is covered. The description adds that the colors are 'extracted' and tied to 'wallbash', which hints at derivation, but says nothing about what happens if no wallpaper is set or how stale the palette may be.

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

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

A single front-loaded sentence with no filler. The parenthetical 'wallbash colors' is the only mildly jargon-y addition, but it earns its place by disambiguating the source of the palette.

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

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

With no parameters, no output schema and read-only annotations, the definition is close to complete, but because there is no output schema the return shape (list of hex strings? named colors?) is left unclear, and 'wallbash' is unexplained for an agent unfamiliar with the environment.

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

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

Zero parameters, so the baseline of 4 applies; there is no parameter semantics to document and the description doesn't need to carry 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?

States a specific verb (Get) and resource (extracted color palette from the current wallpaper), with the parenthetical 'wallbash colors' clarifying the derivation. It is distinguishable from siblings like get_wallpaper, list_theme_wallpapers and pick_color, though it doesn't explicitly mention 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?

Usage is only implied by the getter framing: call it when you need the wallpaper-derived palette. There is no statement of when to prefer it over pick_color or get_current_theme, nor any preconditions (e.g., whether a wallpaper must be set).

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is clear. The description adds useful behavioral context by specifying that the result is a line number in config.ctl, which helps an agent interpret the return value beyond the annotations.

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

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

The description is a single front-loaded sentence with no filler. Every phrase contributes either the action, the target resource, or the meaning of the returned value.

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

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

For a simple, side-effect-free getter with no input parameters and no output schema, the description is complete: it says what is fetched and what the result represents. Nothing else is needed for an agent to call it correctly.

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

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

The tool takes zero parameters, so there is no parameter semantics to document. Per the rubric baseline for zero-parameter tools, a 4 is appropriate, and the description correctly does not invent parameter details.

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

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

The description uses a specific verb-resource pair ('Get the currently active waybar layout mode') and clarifies the return value as 'line number in config.ctl.' It clearly distinguishes this read operation from siblings like set_waybar_mode, next_waybar_mode, and toggle_waybar.

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

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

Usage is implied by the read-oriented verb and by contrast with mutating siblings, but the description does not explicitly state when to prefer this tool over get_wallbash_mode or the mode-changing siblings. It provides enough context to infer the intended use but lacks explicit 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description usefully confirms the operation is a toggle (reversible state change) and that it targets the focused window, but it doesn't explain what happens when no group exists or how existing groups are affected.

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

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

A single front-loaded sentence with no filler; the verb and target appear immediately with the clarifying parenthetical in place.

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

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

For a zero-param toggle this is reasonably complete, and annotations carry the safety profile with no output schema needed. However, it omits the behavioral edge cases (what grouping does to the current layout, whether a minimum window count is required) that an agent would need to invoke it confidently.

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