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

Annotations already provide destructiveHint=true and idempotentHint=false, and the description adds valuable context by warning that some cua-driver tools 'can control apps or modify local state' and that the daemon enforces its own permission mode. This goes beyond the structured annotations and helps the agent anticipate side effects and permission-related failures.

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

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

The description is three short sentences with no filler. The core action is front-loaded, followed by a concise risk warning and a clear prerequisite. Every sentence contributes new 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 dynamic generic invoker, the description covers the essential operational context: what it does, that side effects vary, that daemon permissions apply, and how to discover an unknown schema. With a 100%-covered input schema and an output schema present, no critical guidance is obviously missing, though the description could slightly expand on what happens when the daemon denies permission.

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 that 'name' comes from openmausbot_list_cua_tools and that 'arguments' must match the schema returned by describe_cua_tool. The description's mention to call describe_cua_tool first is useful operational guidance but does not add meaning beyond the parameter schema.

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

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

The description opens with a specific action: 'Invoke one cua-driver tool', which clearly identifies the tool as the execution entry point rather than a listing or describing operation. The warning that 'some tools can control apps or modify local state' adds important scope and helps distinguish this invoker from siblings like openmausbot_list_cua_tools and openmausbot_describe_cua_tool.

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

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

The description explicitly tells the agent to 'Call openmausbot_describe_cua_tool first when the input schema is not known', which is a clear prerequisite and usage rule. It also notes that the connected daemon applies its own permission mode, signaling that invocation may be gated. It does not explicitly state when not to use the tool, but the guidance is strong and actionable.

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

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

Annotations already signal readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds small context by clarifying that no installation occurs and that the check targets the configured release channel, but it does not address return behavior or any other runtime details. No contradiction with annotations.

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

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

A single, front-loaded sentence communicates the action, scope, and key side-effect disclaimer with no filler. Every phrase adds 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 zero-parameter read-only check with an output schema and safety annotations, the description is sufficient. Nothing about invocation or output format is needed because the output schema covers return structure.

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

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

The tool has zero parameters, so there is no parameter documentation burden. The description's reference to the 'configured' release channel confirms the tool operates on existing configuration rather than requiring 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 action ('Check'), a specific target ('configured cua-driver release channel'), and explicitly scopes out installation ('without installing anything'). This clearly distinguishes the tool from a hypothetical update/install action and from sibling status/list tools.

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

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

The description conveys that this is a safe, non-installing check, so an agent can infer it is appropriate when merely inspecting update availability. It does not explicitly state when to prefer it over siblings or when not to use it, leaving the routing largely 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 the operation safe (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description does not need to prove the absence of side effects. It adds value by enumerating the specific permission types covered (Accessibility, Screen Recording), which goes beyond the annotation title.

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

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

The description is a single front-loaded sentence that communicates purpose and scope with no filler. Every word contributes to the agent's understanding.

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

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

For a zero-parameter, read-only status tool with an output schema and safety annotations, the description is functionally complete. It misses only explicit usage context and the macOS framing, though the annotation title supplies the macOS context.

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?

This tool has zero parameters and the schema fully documents an empty property set, so there is no parameter information for the description to add. The baseline for a no-parameter tool applies.

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

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

The description states a specific verb ('Report') and a specific resource ('Accessibility and Screen Recording permission status'). It also clearly distinguishes this tool from sibling status tools like cua_skills_status and cua_check_update by naming the exact permission categories being reported.

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

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

The description provides no guidance on when to use this tool versus alternatives, when not to use it, or what conditions would make it the right choice. The agent must infer usage entirely from the tool name and general context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds modest context by framing the operation as a status report, but does not add deeper behavioral detail such as what data is returned or how statuses are computed.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the tool's purpose and 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, idempotent status tool with an output schema present, the description is sufficient. An agent has everything it needs to select and invoke the tool correctly without additional behavior or parameter details.

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 description has no parameter documentation burden. The baseline for a zero-parameter tool is 4, and nothing in the description contradicts or fails to support the empty schema.

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

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

The description uses a specific verb ('Report') and a specific resource ('cua-driver skill pack installation status') with a scope qualifier ('for supported agents'). This clearly distinguishes it from sibling tools such as cua_permissions_status and cua_check_update, which cover different concerns.

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

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

The description gives clear context: this tool is for checking installation status of the cua-driver skill pack. It does not explicitly name alternatives or exclusion conditions, but the intent is evident and the zero-parameter signature makes misuse unlikely.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that it returns the tool's description and JSON input schema, which is useful context about the output but not additional behavioral detail. No contradictions with annotations; the description aligns with the read-only nature.

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

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

The description is a single, succinct sentence with no filler. It states the action and the resource efficiently. Every word earns its place, and the most important information is front-loaded.

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

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

The tool is simple: one required parameter with a clear description, an output schema provided (as indicated by context), and annotations covering safety. The description is sufficient for an agent to correctly invoke it and understand what it will return. There are no missing pieces for a task of this simplicity.

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

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

The schema description for the 'name' parameter is highly informative: 'Exact cua-driver tool name returned by openmausbot_list_cua_tools.' This tells the agent exactly where to obtain the value, adding meaning beyond the basic type and pattern constraints. Schema coverage is 100%, so the description complements rather than compensates.

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

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

The description clearly states the action ('Return') and the resource ('description and JSON input schema for one cua-driver tool'). It distinguishes itself from siblings like openmausbot_list_cua_tools (which lists all tools) and openmausbot_call_cua_tool (which invokes a tool). An agent can immediately understand what this tool does and how it differs from related tools.

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

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

The description implies usage: to fetch metadata for a specific tool. The parameter description explicitly states that the name must be 'returned by openmausbot_list_cua_tools', providing a clear prerequisite and indicating that one should list tools first. It doesn't explicitly state when not to use it, but the context is obvious given the sibling names and the parameter 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety and side-effect profile. The description adds no extra behavioral context (e.g., whether the returned JSON is structured a certain way, any caching, or auth needs). With annotations present, the bar is lower, and the description does not contradict them, but it also doesn't enrich beyond the annotations. A 3 is appropriate.

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

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

The description is a single concise sentence that immediately communicates the action and resource. No filler, no redundant phrasing. It is appropriately front-loaded and earns every word.

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 an output schema (indicated by 'Has output schema: true'), the description is sufficient for a simple read operation. It tells the agent what the tool does. It doesn't mention edge cases (e.g., missing file), but the output schema likely covers return structure. For a trivial getter, this is nearly complete.

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

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

The tool has zero parameters and schema description coverage is 100% (trivially, since none exist). The description doesn't need to explain parameters. For 0-param tools, baseline 4 is prescribed, and the description doesn't detract from that. It's a simple read with no input semantics to clarify.

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

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

The description clearly states a specific action ('Read') and a well-defined resource ('OpenMausBot's companion settings JSON file'). This distinguishes it from the sibling 'set_companion_setting' by opposing read vs. write operations, though it doesn't explicitly contrast with the status or cua tools. It's specific but not fully differentiated from all siblings.

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

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

The description implies the tool should be used when one needs to read the companion settings, but it offers no explicit guidance on when to choose it over alternatives or any prerequisites. There is no mention of when not to use it or when to use the setter instead. For a simple read tool, 'implied usage' is acceptable, which aligns with a score of 3.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful scoping context ('cua-driver bundled with OpenMausBot') but does not disclose additional behavioral details such as output structure or whether the list is static or dynamically discovered.

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 entire description is one tight sentence with no filler. The verb and scope are front-loaded, and every word earns its place.

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

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

This is a simple, zero-argument, read-only listing tool with rich annotations and an output schema. Nothing an agent needs to call it correctly is missing, and the description fully covers the operation's scope.

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

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

The tool has zero parameters, and the schema is fully empty and unambiguous. With no parameters to explain, the description does not need to compensate for schema gaps.

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

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

The description uses a specific verb ('List') and a precise resource ('every tool exposed by the cua-driver bundled with OpenMausBot'). It clearly distinguishes this inventory tool from siblings that describe or call individual CUA tools.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives such as openmausbot_describe_cua_tool or openmausbot_call_cua_tool. The intended use is only implied by the word 'List', 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?

The description adds the atomicity guarantee and the constraint that only one existing key is updated, which are not captured by the annotations alone. The annotations already provide idempotency, non-destructiveness, and non-read-only status, and the description does not contradict 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, tightly written sentence conveys the core behavior with no filler or redundant phrasing. The key qualifiers ('atomically', 'one existing key') are front-loaded, making the description immediately scannable.

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

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

For a simple two-parameter atomic setter, the description, schema, annotations, and output schema provide enough context for correct invocation. A minor gap is the lack of explicit guidance on when to use this versus related companion-setting tools, but the low complexity and strong schema coverage keep the definition complete.

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

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

The input schema already fully documents both parameters, including that 'key' must be an existing companion setting key and 'value' is a new JSON-compatible value. With 100% schema coverage, the description's contribution is minimal but acceptable; it adds the atomic update framing without needing to repeat 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 ('update') and resource ('one existing key in OpenMausBot's companion settings'), making the tool's function immediately clear. It also distinguishes itself from sibling read/list tools like openmausbot_get_companion_settings by focusing on a targeted mutation of a single existing key.

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: this is the tool to use when updating an existing companion setting key, and it excludes creating new keys by requiring an existing key. However, it does not explicitly state when to prefer this over alternatives or mention sibling tools such as openmausbot_get_companion_settings for reading settings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context by specifying what is checked ('discovery' and the daemon) and reinforces the no-state-change behavior, but it does not disclose other behavioral traits such as latency, failure modes, or whether it requires a running daemon.

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 conveys both the action and the no-state-change guarantee without filler. Every word contributes meaning, and the phrasing is immediately scannable.

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

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

The tool is simple (no parameters) and has an output schema, so return-value details do not need to be in the description. Given the number of sibling status tools, the description could more explicitly explain what makes this status check distinct, but the core information needed to invoke it is present.

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

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

The tool has zero parameters, so there is no parameter semantics burden. The baseline of 4 applies because the description does not need to explain any input fields.

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

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

The description names a specific verb ('Check') and concrete resources ('discovery' and 'the live cua-driver daemon'), which clearly indicates the tool's scope. It does not explicitly contrast with sibling status tools like openmausbot_cua_skills_status or openmausbot_cua_permissions_status, but the mention of 'discovery' and 'daemon' provides enough distinction to avoid obvious confusion.

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

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

No guidance is given about when to choose this tool over the various sibling status tools. The description implies it is for general status checking, but it does not state exclusions, prerequisites, or scenarios where another tool would be more appropriate.

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